luxlabs 1.0.19 → 1.0.21

package/commands/dev.js

@@ -124,12 +124,21 @@ async function dev(options = {}) {
   }
 }
 
+/**
+ * Get the correct next binary path for the current platform
+ * Points directly to Next.js CLI JS file to bypass .bin shell script wrappers (cross-platform)
+ */
+function getNextBinPath() {
+  return './node_modules/next/dist/bin/next';
+}
+
 /**
  * Check and install npm dependencies if needed
  */
 async function checkDependencies() {
   const nodeModulesExists = fs.existsSync('node_modules');
-  const nextBinExists = fs.existsSync('./node_modules/.bin/next');
+  const nextBinPath = getNextBinPath();
+  const nextBinExists = fs.existsSync(nextBinPath);
 
   if (!nodeModulesExists || !nextBinExists) {
     console.log(chalk.yellow('📦 Installing dependencies...'));
@@ -157,7 +166,7 @@ async function startDevServer(port) {
   return new Promise((resolve, reject) => {
     console.log(chalk.dim(`Starting Next.js on port ${port}...`));
 
-    const nextBin = './node_modules/.bin/next';
+    const nextBin = getNextBinPath();
     const nodePath = getNodePath();
     const nodeEnv = getNodeEnv();
 

package/commands/flows.js

@@ -56,7 +56,7 @@ async function getCapturedPayload(token) {
 async function getWorkflowDraft(workflowId) {
   const apiUrl = getApiUrl();
   const { data } = await axios.get(
-    `${apiUrl}/api/workflows/${workflowId}/draft`,
+    `${apiUrl}/api/flows/${workflowId}/draft`,
     { headers: getAuthHeaders() }
   );
   return data;
@@ -68,7 +68,7 @@ async function getWorkflowDraft(workflowId) {
 async function saveWorkflowDraft(workflowId, config) {
   const apiUrl = getApiUrl();
   await axios.put(
-    `${apiUrl}/api/workflows/${workflowId}/draft`,
+    `${apiUrl}/api/flows/${workflowId}/draft`,
     { config },
     { headers: getAuthHeaders() }
   );
@@ -255,7 +255,7 @@ ${chalk.bold('Examples:')}
       case 'sync': {
         info('Syncing flows from cloud...');
 
-        const { data } = await axios.get(`${apiUrl}/api/workflows?include_config=true`, {
+        const { data } = await axios.get(`${apiUrl}/api/flows?include_config=true`, {
           headers: getAuthHeaders(),
         });
 
@@ -388,7 +388,7 @@ ${chalk.bold('Examples:')}
 
         info(`Loading flow: ${flowId}`);
         const { data } = await axios.get(
-          `${apiUrl}/api/workflows/${flowId}`,
+          `${apiUrl}/api/flows/${flowId}`,
           { headers: getAuthHeaders() }
         );
 
@@ -472,9 +472,9 @@ ${chalk.bold('Examples:')}
                 metadata: newFlow.metadata || {},
               };
 
-              // Step 1: Create workflow in cloud database (this generates a cloud UUID)
+              // Step 1: Create flow in cloud database (this generates a cloud UUID)
               const createResponse = await axios.post(
-                `${apiUrl}/api/workflows`,
+                `${apiUrl}/api/flows`,
                 {
                   name: newFlow.name,
                   description: newFlow.description,
@@ -490,9 +490,9 @@ ${chalk.bold('Examples:')}
 
               info(`Created in cloud with ID: ${cloudId}`);
 
-              // Step 2: Publish the workflow (copies draft config to published)
+              // Step 2: Publish the flow (copies draft config to published)
               const publishResponse = await axios.post(
-                `${apiUrl}/api/workflows/${cloudId}/publish`,
+                `${apiUrl}/api/flows/${cloudId}/publish`,
                 {},
                 { headers: getAuthHeaders() }
               );
@@ -515,6 +515,8 @@ ${chalk.bold('Examples:')}
                 // Cloud sync tracking - matches markFlowPublished()
                 cloudPublishedAt: now,
                 cloudStatus: 'published',
+                // Track who deployed (for teammate detection)
+                lastDeployedBy: publishResponse.data.triggeredBy || null,
               };
               saveLocalFlow(flowId, updatedFlow);
 
@@ -615,7 +617,7 @@ ${chalk.bold('Examples:')}
         };
 
         const { data } = await axios.post(
-          `${apiUrl}/api/workflows/${flowId}/publish`,
+          `${apiUrl}/api/flows/${flowId}/publish`,
           {
             name: localFlow.name,
             description: localFlow.description,
@@ -642,6 +644,8 @@ ${chalk.bold('Examples:')}
           // Cloud sync tracking - matches markFlowPublished()
           cloudPublishedAt: now,
           cloudStatus: 'published',
+          // Track who deployed (for teammate detection)
+          lastDeployedBy: data.triggeredBy || null,
         };
         saveLocalFlow(flowId, updatedFlow);
 

package/commands/knowledge.js

@@ -5,9 +5,15 @@ const path = require('path');
 const FormData = require('form-data');
 const {
   getApiUrl,
+  getStudioApiUrl,
   getAuthHeaders,
   isAuthenticated,
+  getProjectId,
+  getOrgId,
 } = require('../lib/config');
+
+// Public R2 URL for the lux-knowledge bucket
+const R2_PUBLIC_URL = 'https://pub-12ee5415430243b7bfc167df804f52e2.r2.dev';
 const {
   error,
   success,
@@ -36,138 +42,163 @@ ${chalk.bold('Usage:')} lux knowledge <command> [args]
 
 ${chalk.bold('Document Commands:')}
   list                              List all documents and folders
-  get <document-id>                 Get document details and content
-  url <document-id>                 Get public URL for a document
-  upload <file-path> [folder-id]    Upload a file to knowledge base
-  delete <document-id>              Delete a document
+  get <file-path>                   Get document details and content
+  url <file-path>                   Get public URL for a document
+  upload <local-file> [folder]      Upload a file to knowledge base
+  delete <file-path>                Delete a document
 
 ${chalk.bold('Folder Commands:')}
   folders list                      List all folders
-  folders create <name> [parent-id] Create a new folder
-  folders delete <folder-id>        Delete a folder
+  folders create <folder-path>      Create a new folder
+  folders delete <folder-path>      Delete a folder and all contents
 
 ${chalk.bold('Examples:')}
   lux knowledge list
-  lux knowledge get doc_123abc
+  lux knowledge get custom-designs/blanks/blank-white-front.png
+  lux knowledge url custom-designs/blanks/blank-white-front.png
   lux knowledge upload ./data.json
-  lux knowledge upload ./image.png folder_xyz
-  lux knowledge folders create "Product Docs"
+  lux knowledge upload ./image.png custom-designs/blanks
+  lux knowledge folders create product-docs
+  lux knowledge folders delete product-docs
 `);
     process.exit(0);
   }
 
   const apiUrl = getApiUrl();
+  const studioApiUrl = getStudioApiUrl();
+  const projectId = getProjectId();
 
   try {
     // ============ DOCUMENT COMMANDS ============
     if (command === 'list') {
       info('Loading knowledge base...');
 
-      const [foldersRes, docsRes] = await Promise.all([
-        axios.get(`${apiUrl}/api/knowledge/folders`, {
-          headers: getAuthHeaders(),
-        }),
-        axios.get(`${apiUrl}/api/knowledge/documents`, {
-          headers: getAuthHeaders(),
-        }),
-      ]);
+      const { data } = await axios.get(
+        `${studioApiUrl}/api/projects/${projectId}/knowledge`,
+        { headers: getAuthHeaders() }
+      );
+
+      if (!data.success) {
+        error(data.error || 'Failed to list knowledge');
+        return;
+      }
 
-      const folders = foldersRes.data.folders || [];
-      const documents = docsRes.data.documents || [];
+      const tree = data.tree || [];
+      const totalFiles = data.totalFiles || 0;
 
-      if (folders.length === 0 && documents.length === 0) {
+      if (tree.length === 0) {
         console.log('\n(No knowledge items found)\n');
         return;
       }
 
-      if (folders.length > 0) {
-        console.log(`\n${chalk.bold('Folders')} (${folders.length}):\n`);
-        formatTable(folders.map(f => ({
-          id: f.id,
-          name: f.name,
-          path: f.path,
-        })));
+      console.log(`\n${chalk.bold('Knowledge Base')} (${totalFiles} files):\n`);
+
+      // Print tree structure
+      function printTree(nodes, indent = '') {
+        for (const node of nodes) {
+          if (node.type === 'folder') {
+            console.log(`${indent}${chalk.blue('📁')} ${chalk.bold(node.name)}/`);
+            if (node.children && node.children.length > 0) {
+              printTree(node.children, indent + '  ');
+            }
+          } else {
+            const size = node.size ? ` (${formatFileSize(node.size)})` : '';
+            console.log(`${indent}${chalk.gray('📄')} ${node.name}${chalk.gray(size)}`);
+          }
+        }
       }
 
-      if (documents.length > 0) {
-        console.log(`\n${chalk.bold('Documents')} (${documents.length}):\n`);
-        formatTable(documents.map(d => ({
-          id: d.id,
-          name: d.name,
-          type: d.document_type || d.file_type || 'unknown',
-          size: formatFileSize(d.file_size),
-          folder: d.folder_id || '(root)',
-        })));
-      }
+      printTree(tree);
       console.log('');
     }
 
     else if (command === 'get') {
-      requireArgs(args.slice(1), 1, 'lux knowledge get <document-id>');
-      const docId = args[1];
+      requireArgs(args.slice(1), 1, 'lux knowledge get <file-path>');
+      const filePath = args[1];
+      const orgId = getOrgId();
 
-      info(`Loading document: ${docId}`);
+      info(`Loading document: ${filePath}`);
       const { data } = await axios.get(
-        `${apiUrl}/api/knowledge/documents/${docId}`,
+        `${studioApiUrl}/api/projects/${projectId}/knowledge/${filePath}`,
         { headers: getAuthHeaders() }
       );
 
-      const doc = data.document;
-      console.log(`\n${chalk.bold('Document Details:')}`);
-      console.log(`  ID: ${doc.id}`);
-      console.log(`  Name: ${doc.name}`);
-      console.log(`  Type: ${doc.document_type || doc.file_type || 'unknown'}`);
-      console.log(`  Size: ${formatFileSize(doc.file_size)}`);
-      console.log(`  Folder: ${doc.folder_id || '(root)'}`);
-
-      if (doc.public_url) {
-        console.log(`  URL: ${doc.public_url}`);
+      if (!data.success) {
+        error(data.error || 'Failed to get file');
+        return;
       }
 
-      if (doc.image_width && doc.image_height) {
-        console.log(`  Dimensions: ${doc.image_width}x${doc.image_height}`);
-        console.log(`  Est. Tokens: ${doc.estimated_tokens || 'N/A'}`);
+      // Extract filename from path
+      const fileName = filePath.split('/').pop() || filePath;
+      const ext = fileName.split('.').pop()?.toLowerCase() || '';
+
+      console.log(`\n${chalk.bold('Document Details:')}`);
+      console.log(`  Path: ${filePath}`);
+      console.log(`  Name: ${fileName}`);
+      console.log(`  Size: ${formatFileSize(data.size)}`);
+      console.log(`  Encoding: ${data.encoding}`);
+      console.log(`  Modified: ${data.modifiedAt || 'N/A'}`);
+
+      // Show public URL for binary files
+      if (data.encoding === 'base64') {
+        const publicUrl = `${R2_PUBLIC_URL}/${orgId}/${projectId}/knowledge/${filePath}`;
+        console.log(`  URL: ${publicUrl}`);
       }
 
-      if (doc.content) {
+      // Show content preview for text files
+      if (data.encoding === 'utf-8' && data.content) {
         console.log(`\n${chalk.bold('Content:')}`);
-        console.log(doc.content.substring(0, 2000));
-        if (doc.content.length > 2000) {
-          console.log(chalk.gray(`\n... (${doc.content.length - 2000} more characters)`));
+        const preview = data.content.substring(0, 2000);
+        console.log(preview);
+        if (data.content.length > 2000) {
+          console.log(chalk.gray(`\n... (${data.content.length - 2000} more characters)`));
         }
       }
       console.log('');
     }
 
     else if (command === 'url') {
-      requireArgs(args.slice(1), 1, 'lux knowledge url <document-id>');
-      const docId = args[1];
+      requireArgs(args.slice(1), 1, 'lux knowledge url <file-path>');
+      const filePath = args[1];
+      const orgId = getOrgId();
 
-      info(`Getting URL for document: ${docId}`);
+      info(`Getting URL for document: ${filePath}`);
+
+      // Verify the file exists by fetching from the project-based knowledge API
       const { data } = await axios.get(
-        `${apiUrl}/api/knowledge/documents/${docId}/presigned-url`,
+        `${studioApiUrl}/api/projects/${projectId}/knowledge/${filePath}`,
         { headers: getAuthHeaders() }
       );
 
+      if (!data.success) {
+        error(data.error || 'Failed to get file');
+        return;
+      }
+
+      // Construct the public R2 URL
+      // Format: https://pub-{bucket-id}.r2.dev/{orgId}/{projectId}/knowledge/{filePath}
+      const publicUrl = `${R2_PUBLIC_URL}/${orgId}/${projectId}/knowledge/${filePath}`;
+
       console.log(`\n${chalk.bold('Public URL:')}`);
-      console.log(data.presignedUrl);
-      console.log(`\nDocument: ${data.document.name} (${formatFileSize(data.document.file_size)})`);
+      console.log(publicUrl);
+      console.log(`\nFile: ${filePath} (${formatFileSize(data.size)})`);
       console.log('');
     }
 
     else if (command === 'upload') {
-      requireArgs(args.slice(1), 1, 'lux knowledge upload <file-path> [folder-id]');
-      const filePath = args[1];
-      const folderId = args[2] || null;
+      requireArgs(args.slice(1), 1, 'lux knowledge upload <local-file> [folder]');
+      const localFilePath = args[1];
+      const folder = args[2] || '';
+      const orgId = getOrgId();
 
       // Check file exists
-      if (!fs.existsSync(filePath)) {
-        error(`File not found: ${filePath}`);
+      if (!fs.existsSync(localFilePath)) {
+        error(`File not found: ${localFilePath}`);
         return;
       }
 
-      const fileName = path.basename(filePath);
-      const fileBuffer = fs.readFileSync(filePath);
+      const fileName = path.basename(localFilePath);
+      const fileBuffer = fs.readFileSync(localFilePath);
       const fileSize = fileBuffer.length;
 
       // Detect MIME type
@@ -187,60 +218,70 @@ ${chalk.bold('Examples:')}
         '.webp': 'image/webp',
         '.svg': 'image/svg+xml',
       };
-      const fileType = mimeTypes[ext] || 'application/octet-stream';
+      const contentType = mimeTypes[ext] || 'application/octet-stream';
 
       info(`Uploading: ${fileName} (${formatFileSize(fileSize)})`);
 
-      // Step 1: Get presigned upload URL
+      // Step 1: Get presigned upload URL from the project-based API
       const { data: uploadData } = await axios.post(
-        `${apiUrl}/api/knowledge/upload`,
-        { fileName, fileType },
+        `${studioApiUrl}/api/projects/${projectId}/knowledge/upload-url`,
+        { path: fileName, contentType, folder },
         { headers: getAuthHeaders() }
       );
 
-      // Step 2: Upload to R2
+      if (!uploadData.success) {
+        error(uploadData.error || 'Failed to get upload URL');
+        return;
+      }
+
+      // Step 2: Upload directly to R2 using presigned URL
       info('Uploading to storage...');
       await axios.put(uploadData.uploadUrl, fileBuffer, {
         headers: {
-          'Content-Type': fileType,
+          'Content-Type': contentType,
         },
         maxBodyLength: Infinity,
         maxContentLength: Infinity,
       });
 
-      // Step 3: Complete upload (save to database)
-      info('Saving document metadata...');
-      const { data: completeData } = await axios.put(
-        `${apiUrl}/api/knowledge/upload`,
-        {
-          filePath: uploadData.filePath,
-          fileName,
-          fileType,
-          folderId,
-          fileSize,
-        },
+      // Step 3: Confirm upload completed
+      info('Confirming upload...');
+      const { data: confirmData } = await axios.post(
+        `${studioApiUrl}/api/projects/${projectId}/knowledge/confirm-upload`,
+        { path: uploadData.path, size: fileSize },
         { headers: getAuthHeaders() }
       );
 
-      success('Document uploaded!');
-      console.log(`  ID: ${completeData.document.id}`);
-      console.log(`  Name: ${completeData.document.name}`);
-      if (completeData.document.public_url) {
-        console.log(`  URL: ${completeData.document.public_url}`);
+      if (!confirmData.success) {
+        error(confirmData.error || 'Failed to confirm upload');
+        return;
       }
+
+      // Construct public URL
+      const publicUrl = `${R2_PUBLIC_URL}/${orgId}/${projectId}/knowledge/${uploadData.path}`;
+
+      success('Document uploaded!');
+      console.log(`  Path: ${uploadData.path}`);
+      console.log(`  Size: ${formatFileSize(fileSize)}`);
+      console.log(`  URL: ${publicUrl}`);
       console.log('');
     }
 
     else if (command === 'delete') {
-      requireArgs(args.slice(1), 1, 'lux knowledge delete <document-id>');
-      const docId = args[1];
+      requireArgs(args.slice(1), 1, 'lux knowledge delete <file-path>');
+      const filePath = args[1];
 
-      info(`Deleting document: ${docId}`);
-      await axios.delete(
-        `${apiUrl}/api/knowledge/documents/${docId}`,
+      info(`Deleting: ${filePath}`);
+      const { data } = await axios.delete(
+        `${studioApiUrl}/api/projects/${projectId}/knowledge/${filePath}`,
         { headers: getAuthHeaders() }
       );
 
+      if (!data.success) {
+        error(data.error || 'Failed to delete file');
+        return;
+      }
+
       success('Document deleted!');
     }
 
@@ -250,67 +291,82 @@ ${chalk.bold('Examples:')}
 
       if (!subCommand || subCommand === 'list') {
         info('Loading folders...');
-        const { data } = await axios.get(`${apiUrl}/api/knowledge/folders`, {
-          headers: getAuthHeaders(),
-        });
+        const { data } = await axios.get(
+          `${studioApiUrl}/api/projects/${projectId}/knowledge`,
+          { headers: getAuthHeaders() }
+        );
 
-        if (!data.folders || data.folders.length === 0) {
+        if (!data.success) {
+          error(data.error || 'Failed to list knowledge');
+          return;
+        }
+
+        // Extract folders from tree
+        const folders = [];
+        function collectFolders(nodes, parentPath = '') {
+          for (const node of nodes) {
+            if (node.type === 'folder') {
+              folders.push({
+                name: node.name,
+                path: node.path,
+              });
+              if (node.children && node.children.length > 0) {
+                collectFolders(node.children, node.path);
+              }
+            }
+          }
+        }
+        collectFolders(data.tree || []);
+
+        if (folders.length === 0) {
           console.log('\n(No folders found)\n');
         } else {
-          console.log(`\nFound ${data.folders.length} folder(s):\n`);
-          formatTable(data.folders.map(f => ({
-            id: f.id,
-            name: f.name,
-            path: f.path,
-            parent: f.parent_id || '(root)',
-          })));
+          console.log(`\nFound ${folders.length} folder(s):\n`);
+          formatTable(folders);
           console.log('');
         }
       }
 
       else if (subCommand === 'create') {
-        requireArgs(args.slice(2), 1, 'lux knowledge folders create <name> [parent-id]');
-        const name = args[2];
-        const parentId = args[3] || null;
-
-        // Calculate path
-        let folderPath = `/${name}`;
-        if (parentId) {
-          // Fetch parent to get its path
-          const { data: foldersData } = await axios.get(`${apiUrl}/api/knowledge/folders`, {
-            headers: getAuthHeaders(),
-          });
-          const parent = (foldersData.folders || []).find(f => f.id === parentId);
-          if (parent) {
-            folderPath = `${parent.path}/${name}`;
-          }
-        }
+        requireArgs(args.slice(2), 1, 'lux knowledge folders create <folder-path>');
+        const folderPath = args[2];
+
+        info(`Creating folder: ${folderPath}`);
 
-        info(`Creating folder: ${name}`);
+        // In R2, folders are virtual - they're created by the folder endpoint
         const { data } = await axios.post(
-          `${apiUrl}/api/knowledge/folders`,
-          { name, parent_id: parentId, path: folderPath },
+          `${studioApiUrl}/api/projects/${projectId}/knowledge/folder/${folderPath}`,
+          {},
           { headers: getAuthHeaders() }
         );
 
+        if (!data.success) {
+          error(data.error || 'Failed to create folder');
+          return;
+        }
+
         success('Folder created!');
-        console.log(`  ID: ${data.folder.id}`);
-        console.log(`  Name: ${data.folder.name}`);
-        console.log(`  Path: ${data.folder.path}`);
+        console.log(`  Path: ${data.path}`);
         console.log('');
       }
 
       else if (subCommand === 'delete') {
-        requireArgs(args.slice(2), 1, 'lux knowledge folders delete <folder-id>');
-        const folderId = args[2];
+        requireArgs(args.slice(2), 1, 'lux knowledge folders delete <folder-path>');
+        const folderPath = args[2];
 
-        info(`Deleting folder: ${folderId}`);
-        await axios.delete(
-          `${apiUrl}/api/knowledge/folders?id=${folderId}`,
+        info(`Deleting folder: ${folderPath}`);
+        const { data } = await axios.delete(
+          `${studioApiUrl}/api/projects/${projectId}/knowledge/${folderPath}`,
           { headers: getAuthHeaders() }
         );
 
-        success('Folder deleted!');
+        if (!data.success) {
+          error(data.error || 'Failed to delete folder');
+          return;
+        }
+
+        const deletedCount = data.deletedCount || 1;
+        success(`Folder deleted! (${deletedCount} item${deletedCount > 1 ? 's' : ''} removed)`);
       }
 
       else {

package/commands/login.js

@@ -177,7 +177,7 @@ async function manualLogin(providedKey) {
     const apiUrl = getApiUrl();
 
     // Validate the API key by making a test request
-    const response = await axios.get(`${apiUrl}/api/workflows`, {
+    const response = await axios.get(`${apiUrl}/api/flows`, {
       headers: {
         Authorization: `Bearer ${apiKey}`,
         'X-Org-Id': extractOrgIdFromKey(apiKey),

package/commands/project.js

@@ -231,7 +231,8 @@ async function deployProject(projectId) {
     createGitignore(projectDir);
 
     // Always configure git user (required for commits)
-    execSync('git config user.email "deploy@uselux.ai"', { cwd: projectDir, stdio: 'pipe' });
+    // Use jason@uselux.ai so Vercel recognizes the commit author as a team member
+    execSync('git config user.email "jason@uselux.ai"', { cwd: projectDir, stdio: 'pipe' });
     execSync('git config user.name "Lux Deploy"', { cwd: projectDir, stdio: 'pipe' });
 
     gitSpinner.succeed('Git repository ready');
@@ -496,7 +497,7 @@ async function deployProject(projectId) {
           // Deploy to cloud API using /publish endpoint
           // The publish endpoint supports CLI auth and will create the flow if it doesn't exist
           const { data: deployData } = await axios.post(
-            `${apiUrl}/api/workflows/${flowId}/publish`,
+            `${apiUrl}/api/flows/${flowId}/publish`,
             {
               // Wrap flow data in config object as expected by /publish
               config: {

package/lib/config.js

@@ -4,48 +4,78 @@ 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 UNIFIED_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;
+
 /**
- * Load active org from shared storage
- * Returns { orgId, orgName } or null
+ * Load the unified config file (~/.lux-studio/config.json)
+ * This is the single source of truth used by both Electron app and CLI
  */
-function loadActiveOrg() {
-  if (!fs.existsSync(ACTIVE_ORG_FILE)) {
+function loadUnifiedConfig() {
+  if (!fs.existsSync(UNIFIED_CONFIG_FILE)) {
     return null;
   }
 
   try {
-    const content = fs.readFileSync(ACTIVE_ORG_FILE, 'utf8');
-    return JSON.parse(content);
+    // 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;
   } catch (error) {
     return null;
   }
 }
 
 /**
- * Load credentials for a specific org
- * Returns { apiKey, orgId, orgName } or null
+ * Load active org from unified config
+ * Returns { orgId, orgName } or null
  */
-function loadOrgCredentials(orgId) {
-  const credentialsPath = path.join(LUX_STUDIO_DIR, orgId, 'credentials.json');
-
-  if (!fs.existsSync(credentialsPath)) {
+function loadActiveOrg() {
+  const unifiedConfig = loadUnifiedConfig();
+  if (!unifiedConfig || !unifiedConfig.currentOrg) {
     return null;
   }
 
-  try {
-    const content = fs.readFileSync(credentialsPath, 'utf8');
-    return JSON.parse(content);
-  } catch (error) {
+  const orgId = unifiedConfig.currentOrg;
+  const orgData = unifiedConfig.orgs?.[orgId];
+
+  return {
+    orgId,
+    orgName: orgData?.name || null,
+  };
+}
+
+/**
+ * Load credentials for a specific org from unified config
+ * Returns { apiKey, orgId, orgName } or null
+ */
+function loadOrgCredentials(orgId) {
+  const unifiedConfig = loadUnifiedConfig();
+  if (!unifiedConfig || !unifiedConfig.orgs?.[orgId]) {
     return null;
   }
+
+  const orgData = unifiedConfig.orgs[orgId];
+  return {
+    apiKey: orgData.apiKey,
+    orgId: orgId,
+    orgName: orgData.name || null,
+  };
 }
 
 /**
  * Load config for the currently active org
- * Reads from ~/.lux-studio/active-org.json to get org, then loads credentials
+ * Reads from unified ~/.lux-studio/config.json
  */
 function loadConfig() {
   // Check for env vars first (for CI/automation)
@@ -56,22 +86,22 @@ function loadConfig() {
     };
   }
 
-  // Load active org from shared storage
-  const activeOrg = loadActiveOrg();
-  if (!activeOrg || !activeOrg.orgId) {
+  const unifiedConfig = loadUnifiedConfig();
+  if (!unifiedConfig || !unifiedConfig.currentOrg) {
     return null;
   }
 
-  // Load credentials for that org
-  const credentials = loadOrgCredentials(activeOrg.orgId);
-  if (!credentials) {
+  const orgId = unifiedConfig.currentOrg;
+  const orgData = unifiedConfig.orgs?.[orgId];
+
+  if (!orgData || !orgData.apiKey) {
     return null;
   }
 
   return {
-    apiKey: credentials.apiKey,
-    orgId: credentials.orgId,
-    orgName: credentials.orgName,
+    apiKey: orgData.apiKey,
+    orgId: orgId,
+    orgName: orgData.name || null,
   };
 }
 
@@ -283,22 +313,14 @@ function deleteLocalFlow(flowId) {
 }
 
 /**
- * Get the current project ID from org config
+ * Get the current project ID from unified config
  * Defaults to 'default' if not set
  */
 function getProjectId() {
-  const orgId = getOrgId();
-  if (!orgId) return 'default';
+  const unifiedConfig = loadUnifiedConfig();
+  if (!unifiedConfig) 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';
-  }
+  return unifiedConfig.currentProject || 'default';
 }
 
 /**
@@ -392,6 +414,7 @@ module.exports = {
   saveConfig,
   loadActiveOrg,
   loadOrgCredentials,
+  loadUnifiedConfig,
   loadInterfaceConfig,
   saveInterfaceConfig,
   getApiUrl,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "luxlabs",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "CLI tool for Lux - Upload and deploy interfaces from your terminal",
   "author": "Jason Henkel <jason@uselux.ai>",
   "license": "SEE LICENSE IN LICENSE",