luxlabs 1.0.21 → 1.0.24

package/lib/config.js

@@ -3,79 +3,141 @@ const path = require('path');
 const os = require('os');
 
 // Shared storage directory (used by both Electron app and CLI)
+// Must match Electron ConfigService path: ~/.lux-studio on all platforms
 const LUX_STUDIO_DIR = path.join(os.homedir(), '.lux-studio');
-const UNIFIED_CONFIG_FILE = path.join(LUX_STUDIO_DIR, 'config.json');
+
+// Unified config file path
+const CONFIG_FILE = path.join(LUX_STUDIO_DIR, 'config.json');
 const INTERFACE_FILE = '.lux/interface.json';
 
-// Cache for unified config to avoid repeated file reads
-let _unifiedConfigCache = null;
-let _unifiedConfigMtime = null;
+// Short folder names (to reduce path length for Windows 260 char limit)
+const FOLDER_NAMES = {
+  projects: 'p',
+  interfaces: 'i',
+  flows: 'f',
+  'voice-agents': 'v',
+  data: 'd',
+  knowledge: 'k',
+};
 
 /**
- * Load the unified config file (~/.lux-studio/config.json)
- * This is the single source of truth used by both Electron app and CLI
+ * Load the unified config from ~/.lux-studio/config.json
+ * Returns the full config object or default structure
  */
 function loadUnifiedConfig() {
-  if (!fs.existsSync(UNIFIED_CONFIG_FILE)) {
-    return null;
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return {
+      currentOrg: null,
+      currentProject: null,
+      orgs: {},
+      settings: {},
+    };
   }
 
   try {
-    // Check if file has changed since last read
-    const stats = fs.statSync(UNIFIED_CONFIG_FILE);
-    if (_unifiedConfigCache && _unifiedConfigMtime && stats.mtimeMs === _unifiedConfigMtime) {
-      return _unifiedConfigCache;
-    }
-
-    const content = fs.readFileSync(UNIFIED_CONFIG_FILE, 'utf8');
-    _unifiedConfigCache = JSON.parse(content);
-    _unifiedConfigMtime = stats.mtimeMs;
-    return _unifiedConfigCache;
+    const content = fs.readFileSync(CONFIG_FILE, 'utf8');
+    return JSON.parse(content);
   } catch (error) {
-    return null;
+    return {
+      currentOrg: null,
+      currentProject: null,
+      orgs: {},
+      settings: {},
+    };
   }
 }
 
 /**
- * Load active org from unified config
- * Returns { orgId, orgName } or null
+ * Save the unified config to ~/.lux-studio/config.json
  */
-function loadActiveOrg() {
-  const unifiedConfig = loadUnifiedConfig();
-  if (!unifiedConfig || !unifiedConfig.currentOrg) {
-    return null;
+function saveUnifiedConfig(config) {
+  const dir = path.dirname(CONFIG_FILE);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
   }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
 
-  const orgId = unifiedConfig.currentOrg;
-  const orgData = unifiedConfig.orgs?.[orgId];
+/**
+ * Register a new short ID for a full UUID with collision detection.
+ * This must match the Electron ConfigService.registerShortId logic exactly.
+ */
+function registerShortId(fullId) {
+  if (!fullId) return fullId;
 
-  return {
-    orgId,
-    orgName: orgData?.name || null,
-  };
+  const config = loadUnifiedConfig();
+  const mappings = config.idMappings || {};
+
+  // If already registered, return existing
+  if (mappings[fullId]) {
+    return mappings[fullId];
+  }
+
+  // Remove hyphens from UUID
+  const cleanId = fullId.replace(/-/g, '');
+
+  // Get all existing short IDs for collision detection
+  const existingShortIds = new Set(Object.values(mappings));
+
+  // Try last 8 chars, then 9, 10, etc. until no collision
+  let length = 8;
+  let shortId = cleanId.slice(-length);
+
+  while (existingShortIds.has(shortId) && length < cleanId.length) {
+    length++;
+    shortId = cleanId.slice(-length);
+  }
+
+  // Store the mapping
+  config.idMappings = config.idMappings || {};
+  config.idMappings[fullId] = shortId;
+  saveUnifiedConfig(config);
+
+  return shortId;
 }
 
 /**
- * Load credentials for a specific org from unified config
- * Returns { apiKey, orgId, orgName } or null
+ * Get the short ID for a full UUID from the config mappings.
+ * If no mapping exists, registers a new one with collision detection.
  */
-function loadOrgCredentials(orgId) {
-  const unifiedConfig = loadUnifiedConfig();
-  if (!unifiedConfig || !unifiedConfig.orgs?.[orgId]) {
-    return null;
+function getShortId(fullId) {
+  if (!fullId) return fullId;
+
+  const config = loadUnifiedConfig();
+  const mappings = config.idMappings || {};
+
+  // Return existing mapping if found
+  if (mappings[fullId]) {
+    return mappings[fullId];
   }
 
-  const orgData = unifiedConfig.orgs[orgId];
-  return {
-    apiKey: orgData.apiKey,
-    orgId: orgId,
-    orgName: orgData.name || null,
-  };
+  // Register a new short ID with collision detection
+  return registerShortId(fullId);
+}
+
+/**
+ * Get the full UUID from a short ID.
+ * Returns null if not found.
+ */
+function getFullId(shortId) {
+  if (!shortId) return null;
+
+  const config = loadUnifiedConfig();
+  const mappings = config.idMappings || {};
+
+  // Reverse lookup
+  for (const [fullId, mappedShortId] of Object.entries(mappings)) {
+    if (mappedShortId === shortId) {
+      return fullId;
+    }
+  }
+
+  return null;
 }
 
 /**
  * Load config for the currently active org
- * Reads from unified ~/.lux-studio/config.json
+ * Returns { apiKey, orgId, orgName } or null
  */
 function loadConfig() {
   // Check for env vars first (for CI/automation)
@@ -86,22 +148,52 @@ function loadConfig() {
     };
   }
 
-  const unifiedConfig = loadUnifiedConfig();
-  if (!unifiedConfig || !unifiedConfig.currentOrg) {
+  // Load from unified config
+  const config = loadUnifiedConfig();
+
+  if (!config.currentOrg) {
     return null;
   }
 
-  const orgId = unifiedConfig.currentOrg;
-  const orgData = unifiedConfig.orgs?.[orgId];
+  const orgConfig = config.orgs[config.currentOrg];
+  if (!orgConfig || !orgConfig.apiKey) {
+    return null;
+  }
 
-  if (!orgData || !orgData.apiKey) {
+  return {
+    apiKey: orgConfig.apiKey,
+    orgId: config.currentOrg,
+    orgName: orgConfig.name,
+  };
+}
+
+/**
+ * @deprecated Use loadConfig() instead - reads from unified config.json
+ */
+function loadActiveOrg() {
+  const config = loadUnifiedConfig();
+  if (!config.currentOrg) {
     return null;
   }
+  return {
+    orgId: config.currentOrg,
+    orgName: config.orgs[config.currentOrg]?.name,
+  };
+}
 
+/**
+ * @deprecated Use loadConfig() instead - reads from unified config.json
+ */
+function loadOrgCredentials(orgId) {
+  const config = loadUnifiedConfig();
+  const orgConfig = config.orgs[orgId];
+  if (!orgConfig) {
+    return null;
+  }
   return {
-    apiKey: orgData.apiKey,
+    apiKey: orgConfig.apiKey,
     orgId: orgId,
-    orgName: orgData.name || null,
+    orgName: orgConfig.name,
   };
 }
 
@@ -203,23 +295,28 @@ function getOrgId() {
 
 /**
  * Get the flows directory for the current org/project
- * Returns: ~/.lux-studio/{orgId}/projects/{projectId}/flows/
+ * Returns: ~/.lux-studio/{shortOrgId}/p/{shortProjectId}/f/
  */
 function getFlowsDir() {
   const orgId = getOrgId();
   const projectId = getProjectId();
   if (!orgId || !projectId) return null;
-  return path.join(LUX_STUDIO_DIR, orgId, 'projects', projectId, 'flows');
+  const shortOrgId = getShortId(orgId);
+  const shortProjectId = getShortId(projectId);
+  return path.join(LUX_STUDIO_DIR, shortOrgId, FOLDER_NAMES.projects, shortProjectId, FOLDER_NAMES.flows);
 }
 
 /**
  * Load a flow from local storage
+ * New folder structure: flows/{shortFlowId}/draft.json
  */
 function loadLocalFlow(flowId) {
   const flowsDir = getFlowsDir();
   if (!flowsDir) return null;
 
-  const flowPath = path.join(flowsDir, `${flowId}.json`);
+  // Use short ID for folder path
+  const shortFlowId = getShortId(flowId);
+  const flowPath = path.join(flowsDir, shortFlowId, 'draft.json');
   if (!fs.existsSync(flowPath)) return null;
 
   try {
@@ -231,27 +328,31 @@ function loadLocalFlow(flowId) {
 
 /**
  * Save a flow to local storage
- * Matches Electron storage service pattern: main file + separate .deployed.json
+ * New folder structure: flows/{shortFlowId}/draft.json, deployed.json
  */
 function saveLocalFlow(flowId, flowData) {
   const flowsDir = getFlowsDir();
   if (!flowsDir) return false;
 
-  // Ensure directory exists
-  if (!fs.existsSync(flowsDir)) {
-    fs.mkdirSync(flowsDir, { recursive: true });
+  // Use short ID for folder path
+  const shortFlowId = getShortId(flowId);
+  const flowDir = path.join(flowsDir, shortFlowId);
+
+  // Ensure flow directory exists
+  if (!fs.existsSync(flowDir)) {
+    fs.mkdirSync(flowDir, { recursive: true });
   }
 
   // Extract deployed data (same pattern as Electron storage service)
   const { deployedNodes, deployedEdges, ...flowWithoutDeployed } = flowData;
 
-  // Write main flow file (without deployed data)
-  const flowPath = path.join(flowsDir, `${flowId}.json`);
-  fs.writeFileSync(flowPath, JSON.stringify(flowWithoutDeployed, null, 2));
+  // Write draft file (without deployed data)
+  const draftPath = path.join(flowDir, 'draft.json');
+  fs.writeFileSync(draftPath, JSON.stringify(flowWithoutDeployed, null, 2));
 
   // Write deployed data to separate file (if present)
   if (deployedNodes || deployedEdges) {
-    const deployedPath = path.join(flowsDir, `${flowId}.deployed.json`);
+    const deployedPath = path.join(flowDir, 'deployed.json');
     fs.writeFileSync(deployedPath, JSON.stringify({
       deployedNodes: deployedNodes || [],
       deployedEdges: deployedEdges || [],
@@ -263,17 +364,22 @@ function saveLocalFlow(flowId, flowData) {
 
 /**
  * List all local flows with sync status
+ * New folder structure: flows/{shortFlowId}/draft.json
  */
 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);
+  // Now we look for directories, not .json files
+  const entries = fs.readdirSync(flowsDir, { withFileTypes: true });
+  const flowDirs = entries.filter(e => e.isDirectory());
+
+  for (const entry of flowDirs) {
+    const shortFlowId = entry.name;
+    // Get full flow ID from mapping, or use short ID as fallback
+    const fullFlowId = getFullId(shortFlowId) || shortFlowId;
+    const flow = loadLocalFlow(fullFlowId);
     if (flow) {
       // Determine sync status
       let syncStatus = 'draft';
@@ -299,14 +405,18 @@ function listLocalFlows() {
 
 /**
  * Delete a local flow
+ * New folder structure: flows/{shortFlowId}/
  */
 function deleteLocalFlow(flowId) {
   const flowsDir = getFlowsDir();
   if (!flowsDir) return false;
 
-  const flowPath = path.join(flowsDir, `${flowId}.json`);
-  if (fs.existsSync(flowPath)) {
-    fs.unlinkSync(flowPath);
+  // Use short ID for folder path
+  const shortFlowId = getShortId(flowId);
+  const flowDir = path.join(flowsDir, shortFlowId);
+  if (fs.existsSync(flowDir)) {
+    // Remove the entire flow directory
+    fs.rmSync(flowDir, { recursive: true, force: true });
     return true;
   }
   return false;
@@ -314,13 +424,25 @@ function deleteLocalFlow(flowId) {
 
 /**
  * Get the current project ID from unified config
- * Defaults to 'default' if not set
  */
 function getProjectId() {
-  const unifiedConfig = loadUnifiedConfig();
-  if (!unifiedConfig) return 'default';
+  // Check env var first
+  if (process.env.LUX_PROJECT_ID) {
+    return process.env.LUX_PROJECT_ID;
+  }
+
+  const config = loadUnifiedConfig();
 
-  return unifiedConfig.currentProject || 'default';
+  if (config.currentProject) {
+    return config.currentProject;
+  }
+
+  // Fallback: use the first project in the current org
+  if (config.currentOrg && config.orgs?.[config.currentOrg]?.projects?.length) {
+    return config.orgs[config.currentOrg].projects[0];
+  }
+
+  return 'default';
 }
 
 /**
@@ -336,33 +458,37 @@ function slugify(name) {
 
 /**
  * Get the interfaces directory for the current org/project
- * Returns: ~/.lux-studio/{orgId}/projects/{projectId}/interfaces/
+ * Returns: ~/.lux-studio/{shortOrgId}/p/{shortProjectId}/i/
  */
 function getInterfacesDir() {
   const orgId = getOrgId();
   if (!orgId) return null;
 
   const projectId = getProjectId();
-  return path.join(LUX_STUDIO_DIR, orgId, 'projects', projectId, 'interfaces');
+  const shortOrgId = getShortId(orgId);
+  const shortProjectId = getShortId(projectId);
+  return path.join(LUX_STUDIO_DIR, shortOrgId, FOLDER_NAMES.projects, shortProjectId, FOLDER_NAMES.interfaces);
 }
 
 /**
- * Get the directory for a specific interface by slug
- * Returns: ~/.lux-studio/{orgId}/projects/{projectId}/interfaces/{slug}/
+ * Get the directory for a specific interface by slug or ID
+ * Returns: ~/.lux-studio/{shortOrgId}/p/{shortProjectId}/i/{shortInterfaceId}/
  */
-function getInterfaceDir(slug) {
+function getInterfaceDir(slugOrId) {
   const interfacesDir = getInterfacesDir();
   if (!interfacesDir) return null;
 
-  return path.join(interfacesDir, slug);
+  // If it looks like a UUID, use short ID
+  const shortId = getShortId(slugOrId);
+  return path.join(interfacesDir, shortId);
 }
 
 /**
  * Get the repo directory for a specific interface
- * Returns: ~/.lux-studio/{orgId}/projects/{projectId}/interfaces/{slug}/repo/
+ * Returns: ~/.lux-studio/{shortOrgId}/p/{shortProjectId}/i/{shortInterfaceId}/repo/
  */
-function getInterfaceRepoDir(slug) {
-  const interfaceDir = getInterfaceDir(slug);
+function getInterfaceRepoDir(slugOrId) {
+  const interfaceDir = getInterfaceDir(slugOrId);
   if (!interfaceDir) return null;
 
   return path.join(interfaceDir, 'repo');
@@ -391,6 +517,26 @@ function interfaceExists(slug) {
   return interfaceDir && fs.existsSync(interfaceDir);
 }
 
+/**
+ * Load interface metadata by ID
+ * @param {string} id - The interface UUID
+ * @returns {object|null} The metadata object, or null if not found
+ */
+function loadInterfaceMetadata(id) {
+  const interfaceDir = getInterfaceDir(id);
+  if (!interfaceDir) return null;
+
+  const metadataPath = path.join(interfaceDir, 'metadata.json');
+  if (!fs.existsSync(metadataPath)) return null;
+
+  try {
+    const content = fs.readFileSync(metadataPath, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    return null;
+  }
+}
+
 /**
  * Save interface metadata
  * @param {string} slug - The slugified interface name (folder name)
@@ -415,6 +561,7 @@ module.exports = {
   loadActiveOrg,
   loadOrgCredentials,
   loadUnifiedConfig,
+  saveUnifiedConfig,
   loadInterfaceConfig,
   saveInterfaceConfig,
   getApiUrl,
@@ -434,8 +581,13 @@ module.exports = {
   getInterfaceRepoDir,
   ensureInterfaceDir,
   interfaceExists,
+  loadInterfaceMetadata,
   saveInterfaceMetadata,
   slugify,
+  getShortId,
+  getFullId,
+  registerShortId,
   INTERFACE_FILE,
   LUX_STUDIO_DIR,
+  FOLDER_NAMES,
 };

package/lib/helpers.js

@@ -4,6 +4,8 @@
  * Common functions for formatting, validation, and error handling
  */
 
+const chalk = require('chalk');
+
 /**
  * Format output as table
  */
@@ -25,14 +27,14 @@ function formatJson(data, pretty = true) {
  * Print success message
  */
 function success(message) {
-  console.log(`✅ ${message}`);
+  console.log(chalk.green(`[OK] ${message}`));
 }
 
 /**
  * Print error message and exit
  */
 function error(message, exitCode = 1) {
-  console.error(`❌ ${message}`);
+  console.error(chalk.red(`[ERROR] ${message}`));
   process.exit(exitCode);
 }
 
@@ -40,14 +42,14 @@ function error(message, exitCode = 1) {
  * Print warning message
  */
 function warn(message) {
-  console.warn(`⚠️  ${message}`);
+  console.warn(chalk.yellow(`[WARN] ${message}`));
 }
 
 /**
  * Print info message
  */
 function info(message) {
-  console.log(`ℹ️  ${message}`);
+  console.log(chalk.blue(`[INFO] ${message}`));
 }
 
 /**

package/lux.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 
+require('dotenv').config({ quiet: true });
+
 const { program } = require('commander');
 const chalk = require('chalk');
 const packageJson = require('./package.json');
@@ -7,7 +9,6 @@ const packageJson = require('./package.json');
 // Import commands
 const { login } = require('./commands/login');
 const { logout } = require('./commands/logout');
-const { dev } = require('./commands/dev');
 const { handleInterface } = require('./commands/interface');
 const { handleData } = require('./commands/data');
 const { handleStorage } = require('./commands/storage');
@@ -19,8 +20,7 @@ const { handleVoiceAgents } = require('./commands/voice-agents');
 const { handleValidateDataLux } = require('./commands/validate-data-lux');
 const { handlePricing } = require('./commands/pricing');
 const { handleProject } = require('./commands/project');
-const { handleServers, handleLogs } = require('./commands/servers');
-const { handleTest } = require('./commands/webview');
+const { handleServers } = require('./commands/servers');
 const { handleABTests } = require('./commands/ab-tests');
 const { handleTools } = require('./commands/tools');
 const { handleSpec } = require('./commands/spec');
@@ -43,26 +43,11 @@ program
   .description('Log out from Lux')
   .action(logout);
 
-// Dev command - local development with tunnel
-program
-  .command('dev')
-  .description('Start local dev server with tunnel to Lux cloud')
-  .option('-p, --port <port>', 'Port to run dev server on', '3000')
-  .option('--no-tunnel', 'Disable tunnel (local only)')
-  .option('--no-sync', 'Disable auto-sync to GitHub')
-  .action((options) => {
-    dev({
-      port: parseInt(options.port, 10),
-      noTunnel: !options.tunnel,
-      noSync: !options.sync,
-    });
-  });
-
 // Interface commands (with short alias 'i')
 program
   .command('interface [subcommand] [args...]')
   .alias('i')
-  .description('Interface management (up, deploy, list, link, logs)')
+  .description('Interface management (create, deploy, list, logs, path)')
   .allowUnknownOption()
   .action((subcommand, args) => {
     handleInterface(subcommand ? subcommand : 'help', args || []);
@@ -202,81 +187,6 @@ program
     handleServers(subcommand ? [subcommand, ...(args || [])] : []);
   });
 
-// Logs command - view dev server logs
-program
-  .command('logs [interface]')
-  .description('View logs from a running dev server')
-  .option('-f, --follow', 'Follow log output (like tail -f)')
-  .option('-n, --lines <number>', 'Number of lines to show', '50')
-  .option('-c, --console', 'Show browser console logs instead of terminal logs')
-  .action((interfaceArg, options) => {
-    handleLogs(interfaceArg ? [interfaceArg] : [], {
-      follow: options.follow,
-      lines: parseInt(options.lines, 10),
-      console: options.console,
-    });
-  });
-
-// Webview control commands (top-level)
-const { screenshot, click, type: typeText, evaluate, getUrl, navigate, wait } = require('./commands/webview');
-
-program
-  .command('screenshot <interface-id>')
-  .description('Take a screenshot of the interface preview')
-  .action(async (interfaceId) => {
-    await screenshot(interfaceId);
-  });
-
-program
-  .command('click <interface-id> <selector>')
-  .description('Click an element in the interface preview')
-  .action(async (interfaceId, selector) => {
-    await click(interfaceId, selector);
-  });
-
-program
-  .command('type <interface-id> <selector> <text>')
-  .description('Type text into an element in the interface preview')
-  .action(async (interfaceId, selector, text) => {
-    await typeText(interfaceId, selector, text);
-  });
-
-program
-  .command('eval <interface-id> <code>')
-  .description('Execute JavaScript in the interface preview')
-  .action(async (interfaceId, code) => {
-    await evaluate(interfaceId, code);
-  });
-
-program
-  .command('url <interface-id>')
-  .description('Get current URL of the interface preview')
-  .action(async (interfaceId) => {
-    await getUrl(interfaceId);
-  });
-
-program
-  .command('nav <interface-id> <url>')
-  .description('Navigate the interface preview to a URL')
-  .action(async (interfaceId, url) => {
-    await navigate(interfaceId, url);
-  });
-
-program
-  .command('wait <interface-id> <ms>')
-  .description('Wait for a duration (milliseconds)')
-  .action(async (interfaceId, ms) => {
-    await wait(interfaceId, ms);
-  });
-
-program
-  .command('preview <interface-id>')
-  .description('Start the interface preview (opens in Lux Studio)')
-  .action(async (interfaceId) => {
-    const { startPreview } = require('./commands/webview');
-    await startPreview(interfaceId);
-  });
-
 // Project spec command
 program
   .command('spec [subcommand] [args...]')