luxlabs 1.0.0

package/lib/config.js

@@ -0,0 +1,403 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Shared storage directory (used by both Electron app and CLI)
+const LUX_STUDIO_DIR = path.join(os.homedir(), '.lux-studio');
+const ACTIVE_ORG_FILE = path.join(LUX_STUDIO_DIR, 'active-org.json');
+const INTERFACE_FILE = '.lux/interface.json';
+
+/**
+ * Load active org from shared storage
+ * Returns { orgId, orgName } or null
+ */
+function loadActiveOrg() {
+  if (!fs.existsSync(ACTIVE_ORG_FILE)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(ACTIVE_ORG_FILE, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Load credentials for a specific org
+ * Returns { apiKey, orgId, orgName } or null
+ */
+function loadOrgCredentials(orgId) {
+  const credentialsPath = path.join(LUX_STUDIO_DIR, orgId, 'credentials.json');
+
+  if (!fs.existsSync(credentialsPath)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(credentialsPath, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Load config for the currently active org
+ * Reads from ~/.lux-studio/active-org.json to get org, then loads credentials
+ */
+function loadConfig() {
+  // Check for env vars first (for CI/automation)
+  if (process.env.LUX_API_KEY && process.env.LUX_ORG_ID) {
+    return {
+      apiKey: process.env.LUX_API_KEY,
+      orgId: process.env.LUX_ORG_ID,
+    };
+  }
+
+  // Load active org from shared storage
+  const activeOrg = loadActiveOrg();
+  if (!activeOrg || !activeOrg.orgId) {
+    return null;
+  }
+
+  // Load credentials for that org
+  const credentials = loadOrgCredentials(activeOrg.orgId);
+  if (!credentials) {
+    return null;
+  }
+
+  return {
+    apiKey: credentials.apiKey,
+    orgId: credentials.orgId,
+    orgName: credentials.orgName,
+  };
+}
+
+/**
+ * Save config is no longer needed - Electron app manages credentials
+ * Kept for backwards compatibility but does nothing
+ */
+function saveConfig(config) {
+  console.warn('saveConfig is deprecated - credentials are managed by Lux Studio app');
+}
+
+/**
+ * Load interface config (.lux/interface.json)
+ */
+function loadInterfaceConfig() {
+  if (!fs.existsSync(INTERFACE_FILE)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(INTERFACE_FILE, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Save interface config
+ */
+function saveInterfaceConfig(config) {
+  const dir = path.dirname(INTERFACE_FILE);
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  fs.writeFileSync(INTERFACE_FILE, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Get API base URL
+ * For tunnel operations, this should point to the dashboard (Vercel)
+ * For other operations, this points to the org's local server or cloud
+ */
+function getApiUrl() {
+  const config = loadConfig();
+  return config?.apiUrl || process.env.LUX_API_URL || 'https://app.uselux.ai';
+}
+
+/**
+ * Get Studio API URL (for project-scoped operations like tables)
+ * Points to lux-studio-api Cloudflare Worker
+ */
+function getStudioApiUrl() {
+  return process.env.LUX_STUDIO_API_URL || 'https://v2.uselux.ai';
+}
+
+/**
+ * Get Dashboard URL (for tunnel registration)
+ * Always points to the Vercel-hosted dashboard
+ */
+function getDashboardUrl() {
+  return process.env.LUX_DASHBOARD_URL || 'https://app.uselux.ai';
+}
+
+/**
+ * Check if user is authenticated
+ */
+function isAuthenticated() {
+  const config = loadConfig();
+  return config && config.apiKey && config.orgId;
+}
+
+/**
+ * Get auth headers for API requests
+ */
+function getAuthHeaders() {
+  const config = loadConfig();
+
+  if (!config || !config.apiKey || !config.orgId) {
+    return {};
+  }
+
+  return {
+    'Authorization': `Bearer ${config.apiKey}`,
+    'X-Org-Id': config.orgId,
+    'X-Project-Id': getProjectId(),
+  };
+}
+
+/**
+ * Get the org ID from config
+ */
+function getOrgId() {
+  const config = loadConfig();
+  return config?.orgId;
+}
+
+/**
+ * Get the flows directory for the current org/project
+ * Returns: ~/.lux-studio/{orgId}/projects/{projectId}/flows/
+ */
+function getFlowsDir() {
+  const orgId = getOrgId();
+  const projectId = getProjectId();
+  if (!orgId || !projectId) return null;
+  return path.join(LUX_STUDIO_DIR, orgId, 'projects', projectId, 'flows');
+}
+
+/**
+ * Load a flow from local storage
+ */
+function loadLocalFlow(flowId) {
+  const flowsDir = getFlowsDir();
+  if (!flowsDir) return null;
+
+  const flowPath = path.join(flowsDir, `${flowId}.json`);
+  if (!fs.existsSync(flowPath)) return null;
+
+  try {
+    return JSON.parse(fs.readFileSync(flowPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Save a flow to local storage
+ */
+function saveLocalFlow(flowId, flowData) {
+  const flowsDir = getFlowsDir();
+  if (!flowsDir) return false;
+
+  // Ensure directory exists
+  if (!fs.existsSync(flowsDir)) {
+    fs.mkdirSync(flowsDir, { recursive: true });
+  }
+
+  const flowPath = path.join(flowsDir, `${flowId}.json`);
+  fs.writeFileSync(flowPath, JSON.stringify(flowData, null, 2));
+  return true;
+}
+
+/**
+ * List all local flows with sync status
+ */
+function listLocalFlows() {
+  const flowsDir = getFlowsDir();
+  if (!flowsDir || !fs.existsSync(flowsDir)) return [];
+
+  const flows = [];
+  const files = fs.readdirSync(flowsDir).filter(f => f.endsWith('.json'));
+
+  for (const file of files) {
+    const flowId = file.replace('.json', '');
+    const flow = loadLocalFlow(flowId);
+    if (flow) {
+      // Determine sync status
+      let syncStatus = 'draft';
+      if (flow.publishedVersion) {
+        if (flow.cloudVersion && flow.cloudVersion > flow.publishedVersion) {
+          syncStatus = flow.localVersion > flow.publishedVersion ? 'conflict' : 'synced';
+        } else if (flow.localVersion > flow.publishedVersion) {
+          syncStatus = 'dirty';
+        } else {
+          syncStatus = 'synced';
+        }
+      }
+
+      flows.push({
+        ...flow,
+        syncStatus,
+      });
+    }
+  }
+
+  return flows;
+}
+
+/**
+ * Delete a local flow
+ */
+function deleteLocalFlow(flowId) {
+  const flowsDir = getFlowsDir();
+  if (!flowsDir) return false;
+
+  const flowPath = path.join(flowsDir, `${flowId}.json`);
+  if (fs.existsSync(flowPath)) {
+    fs.unlinkSync(flowPath);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Get the current project ID from org config
+ * Defaults to 'default' if not set
+ */
+function getProjectId() {
+  const orgId = getOrgId();
+  if (!orgId) return 'default';
+
+  const orgConfigPath = path.join(LUX_STUDIO_DIR, orgId, 'config.json');
+  if (!fs.existsSync(orgConfigPath)) return 'default';
+
+  try {
+    const orgConfig = JSON.parse(fs.readFileSync(orgConfigPath, 'utf8'));
+    return orgConfig.currentProject || 'default';
+  } catch {
+    return 'default';
+  }
+}
+
+/**
+ * Slugify a name for use as folder name
+ * Converts "My Interface" to "my-interface"
+ */
+function slugify(name) {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+/**
+ * Get the interfaces directory for the current org/project
+ * Returns: ~/.lux-studio/{orgId}/projects/{projectId}/interfaces/
+ */
+function getInterfacesDir() {
+  const orgId = getOrgId();
+  if (!orgId) return null;
+
+  const projectId = getProjectId();
+  return path.join(LUX_STUDIO_DIR, orgId, 'projects', projectId, 'interfaces');
+}
+
+/**
+ * Get the directory for a specific interface by slug
+ * Returns: ~/.lux-studio/{orgId}/projects/{projectId}/interfaces/{slug}/
+ */
+function getInterfaceDir(slug) {
+  const interfacesDir = getInterfacesDir();
+  if (!interfacesDir) return null;
+
+  return path.join(interfacesDir, slug);
+}
+
+/**
+ * Get the repo directory for a specific interface
+ * Returns: ~/.lux-studio/{orgId}/projects/{projectId}/interfaces/{slug}/repo/
+ */
+function getInterfaceRepoDir(slug) {
+  const interfaceDir = getInterfaceDir(slug);
+  if (!interfaceDir) return null;
+
+  return path.join(interfaceDir, 'repo');
+}
+
+/**
+ * Ensure interface directory exists and return the path
+ * @param {string} slug - The slugified interface name
+ */
+function ensureInterfaceDir(slug) {
+  const interfaceDir = getInterfaceDir(slug);
+  if (!interfaceDir) return null;
+
+  if (!fs.existsSync(interfaceDir)) {
+    fs.mkdirSync(interfaceDir, { recursive: true });
+  }
+
+  return interfaceDir;
+}
+
+/**
+ * Check if interface folder already exists by slug
+ */
+function interfaceExists(slug) {
+  const interfaceDir = getInterfaceDir(slug);
+  return interfaceDir && fs.existsSync(interfaceDir);
+}
+
+/**
+ * Save interface metadata
+ * @param {string} slug - The slugified interface name (folder name)
+ * @param {object} metadata - Metadata including { id: uuid, name, ... }
+ */
+function saveInterfaceMetadata(slug, metadata) {
+  const interfaceDir = ensureInterfaceDir(slug);
+  if (!interfaceDir) return false;
+
+  const metadataPath = path.join(interfaceDir, 'metadata.json');
+  fs.writeFileSync(metadataPath, JSON.stringify({
+    ...metadata,
+    updatedAt: new Date().toISOString(),
+  }, null, 2));
+
+  return true;
+}
+
+module.exports = {
+  loadConfig,
+  saveConfig,
+  loadActiveOrg,
+  loadOrgCredentials,
+  loadInterfaceConfig,
+  saveInterfaceConfig,
+  getApiUrl,
+  getStudioApiUrl,
+  getDashboardUrl,
+  isAuthenticated,
+  getAuthHeaders,
+  getOrgId,
+  getFlowsDir,
+  loadLocalFlow,
+  saveLocalFlow,
+  listLocalFlows,
+  deleteLocalFlow,
+  getProjectId,
+  getInterfacesDir,
+  getInterfaceDir,
+  getInterfaceRepoDir,
+  ensureInterfaceDir,
+  interfaceExists,
+  saveInterfaceMetadata,
+  slugify,
+  INTERFACE_FILE,
+  LUX_STUDIO_DIR,
+};

package/lib/helpers.js

@@ -0,0 +1,189 @@
+/**
+ * Shared Helper Utilities
+ *
+ * Common functions for formatting, validation, and error handling
+ */
+
+/**
+ * Format output as table
+ */
+function formatTable(rows) {
+  if (!rows || rows.length === 0) {
+    return '(No results)';
+  }
+  console.table(rows);
+}
+
+/**
+ * Format output as JSON
+ */
+function formatJson(data, pretty = true) {
+  return JSON.stringify(data, null, pretty ? 2 : 0);
+}
+
+/**
+ * Print success message
+ */
+function success(message) {
+  console.log(`✅ ${message}`);
+}
+
+/**
+ * Print error message and exit
+ */
+function error(message, exitCode = 1) {
+  console.error(`❌ ${message}`);
+  process.exit(exitCode);
+}
+
+/**
+ * Print warning message
+ */
+function warn(message) {
+  console.warn(`⚠️  ${message}`);
+}
+
+/**
+ * Print info message
+ */
+function info(message) {
+  console.log(`ℹ️  ${message}`);
+}
+
+/**
+ * Format file size
+ */
+function formatSize(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+/**
+ * Format date
+ */
+function formatDate(timestamp) {
+  if (!timestamp) return 'N/A';
+  const date = new Date(timestamp);
+  return date.toISOString().split('T')[0] + ' ' + date.toTimeString().split(' ')[0];
+}
+
+/**
+ * Validate required arguments
+ */
+function requireArgs(args, count, usage) {
+  if (args.length < count) {
+    error(`Missing required arguments\n\nUsage: ${usage}`);
+  }
+}
+
+/**
+ * Parse JSON safely
+ */
+function parseJson(jsonString, errorContext = 'JSON') {
+  try {
+    return JSON.parse(jsonString);
+  } catch (err) {
+    error(`Invalid ${errorContext}: ${err.message}`);
+  }
+}
+
+/**
+ * Read file safely
+ */
+function readFile(filePath) {
+  const fs = require('fs');
+  try {
+    return fs.readFileSync(filePath, 'utf-8');
+  } catch (err) {
+    error(`Failed to read file ${filePath}: ${err.message}`);
+  }
+}
+
+/**
+ * Write file safely
+ */
+function writeFile(filePath, content) {
+  const fs = require('fs');
+  try {
+    fs.writeFileSync(filePath, content, 'utf-8');
+    success(`Written to ${filePath}`);
+  } catch (err) {
+    error(`Failed to write file ${filePath}: ${err.message}`);
+  }
+}
+
+/**
+ * Check if file exists
+ */
+function fileExists(filePath) {
+  const fs = require('fs');
+  return fs.existsSync(filePath);
+}
+
+/**
+ * Prompt user for input
+ */
+async function prompt(question) {
+  const readline = require('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+/**
+ * Confirm action
+ */
+async function confirm(question) {
+  const answer = await prompt(`${question} (y/n): `);
+  return answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+}
+
+/**
+ * Show loading spinner
+ */
+function spinner(text) {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0;
+
+  const interval = setInterval(() => {
+    process.stdout.write(`\r${frames[i]} ${text}`);
+    i = (i + 1) % frames.length;
+  }, 80);
+
+  return {
+    stop: () => {
+      clearInterval(interval);
+      process.stdout.write('\r');
+    }
+  };
+}
+
+module.exports = {
+  formatTable,
+  formatJson,
+  success,
+  error,
+  warn,
+  info,
+  formatSize,
+  formatDate,
+  requireArgs,
+  parseJson,
+  readFile,
+  writeFile,
+  fileExists,
+  prompt,
+  confirm,
+  spinner
+};

package/lib/node-helper.js

@@ -0,0 +1,120 @@
+/**
+ * Node.js Runtime Helper for CLI
+ *
+ * Provides paths to the bundled Node.js runtime.
+ * This is a CommonJS version for use in CLI scripts.
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const NODE_VERSION = '20.18.1';
+
+/**
+ * Get the base directory for bundled Node.js runtime
+ */
+function getBundledNodeDir() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  // In CLI context, look for resources relative to the CLI location
+  const possiblePaths = [
+    // Development: from bin/lux-cli/lib/
+    path.join(__dirname, '..', '..', '..', 'resources', 'node-runtime'),
+    // Development: from project root
+    path.join(process.cwd(), 'resources', 'node-runtime'),
+    // Packaged: from resources path if available
+    process.resourcesPath ? path.join(process.resourcesPath, 'node-runtime') : null,
+  ].filter(Boolean);
+
+  const baseDir = possiblePaths.find(p => fs.existsSync(p)) || possiblePaths[0];
+
+  return path.join(baseDir, `${platform}-${arch}`);
+}
+
+/**
+ * Get the path to the bundled Node.js binary
+ */
+function getBundledNodePath() {
+  const nodeDir = getBundledNodeDir();
+  const binary = process.platform === 'win32' ? 'node.exe' : 'bin/node';
+  return path.join(nodeDir, binary);
+}
+
+/**
+ * Get the path to the bundled npm binary
+ */
+function getBundledNpmPath() {
+  const nodeDir = getBundledNodeDir();
+
+  if (process.platform === 'win32') {
+    return path.join(nodeDir, 'npm.cmd');
+  }
+
+  return path.join(nodeDir, 'bin', 'npm');
+}
+
+/**
+ * Get environment variables with bundled Node.js in PATH
+ */
+function getBundledNodeEnv() {
+  const nodeDir = getBundledNodeDir();
+  const binPath = process.platform === 'win32' ? nodeDir : path.join(nodeDir, 'bin');
+
+  return {
+    ...process.env,
+    PATH: `${binPath}${path.delimiter}${process.env.PATH}`,
+  };
+}
+
+/**
+ * Check if the bundled Node.js is available
+ */
+function isBundledNodeAvailable() {
+  const nodePath = getBundledNodePath();
+  return fs.existsSync(nodePath);
+}
+
+/**
+ * Get the path to use for node command (with fallback)
+ */
+function getNodePath() {
+  if (isBundledNodeAvailable()) {
+    return getBundledNodePath();
+  }
+  // Fallback to system node
+  return 'node';
+}
+
+/**
+ * Get the path to use for npm command (with fallback)
+ */
+function getNpmPath() {
+  if (isBundledNodeAvailable()) {
+    return getBundledNpmPath();
+  }
+  // Fallback to system npm
+  return 'npm';
+}
+
+/**
+ * Get environment to use for spawning processes
+ */
+function getNodeEnv() {
+  if (isBundledNodeAvailable()) {
+    return getBundledNodeEnv();
+  }
+  return { ...process.env };
+}
+
+module.exports = {
+  NODE_VERSION,
+  getBundledNodeDir,
+  getBundledNodePath,
+  getBundledNpmPath,
+  getBundledNodeEnv,
+  isBundledNodeAvailable,
+  getNodePath,
+  getNpmPath,
+  getNodeEnv,
+};