luxlabs 1.0.0

package/commands/secrets.js

@@ -0,0 +1,129 @@
+const axios = require('axios');
+const chalk = require('chalk');
+const {
+  getApiUrl,
+  getAuthHeaders,
+  isAuthenticated,
+} = require('../lib/config');
+const { error, success, info, formatTable, requireArgs } = require('../lib/helpers');
+
+async function handleSecrets(args) {
+  // Check authentication
+  if (!isAuthenticated()) {
+    console.log(
+      chalk.red('❌ Not authenticated. Run'),
+      chalk.white('lux login'),
+      chalk.red('first.')
+    );
+    process.exit(1);
+  }
+
+  const command = args[0];
+
+  if (!command) {
+    console.log(`
+${chalk.bold('Usage:')} lux secrets <command> [args]
+
+${chalk.bold('Commands:')}
+  list              List all org secrets
+  set <key> <value> Set a secret
+  get <key>         Get secret value
+  delete <key>      Delete a secret
+
+${chalk.bold('Examples:')}
+  lux secrets list
+  lux secrets set OPENAI_API_KEY sk-xxx
+  lux secrets get OPENAI_API_KEY
+  lux secrets delete OPENAI_API_KEY
+`);
+    process.exit(0);
+  }
+
+  const apiUrl = getApiUrl();
+
+  try {
+    switch (command) {
+      case 'list': {
+        info('Loading secrets...');
+        const { data } = await axios.get(`${apiUrl}/api/org/secrets`, {
+          headers: getAuthHeaders(),
+        });
+
+        if (!data.secrets || data.secrets.length === 0) {
+          console.log('\n(No secrets found)\n');
+        } else {
+          console.log(`\nFound ${data.secrets.length} secret(s):\n`);
+          const formatted = data.secrets.map((s) => ({
+            key: s.key,
+            created: new Date(s.created_at).toLocaleDateString(),
+            updated: new Date(s.updated_at).toLocaleDateString(),
+          }));
+          formatTable(formatted);
+          console.log('');
+        }
+        break;
+      }
+
+      case 'set': {
+        requireArgs(args.slice(1), 2, 'lux secrets set <key> <value>');
+        const key = args[1];
+        const value = args.slice(2).join(' '); // Allow spaces in value
+
+        info(`Setting secret: ${key}`);
+        await axios.post(
+          `${apiUrl}/api/org/secrets`,
+          { key, value },
+          { headers: getAuthHeaders() }
+        );
+
+        success(`Secret set: ${key}`);
+        break;
+      }
+
+      case 'get': {
+        requireArgs(args.slice(1), 1, 'lux secrets get <key>');
+        const key = args[1];
+
+        info(`Getting secret: ${key}`);
+        const { data } = await axios.get(
+          `${apiUrl}/api/org/secrets/${encodeURIComponent(key)}`,
+          { headers: getAuthHeaders() }
+        );
+
+        if (!data.secret) {
+          error(`Secret not found: ${key}`);
+        }
+
+        console.log(`\n${chalk.bold(key)}:`);
+        console.log(data.secret.value);
+        console.log('');
+        break;
+      }
+
+      case 'delete': {
+        requireArgs(args.slice(1), 1, 'lux secrets delete <key>');
+        const key = args[1];
+
+        info(`Deleting secret: ${key}`);
+        await axios.delete(
+          `${apiUrl}/api/org/secrets/${encodeURIComponent(key)}`,
+          { headers: getAuthHeaders() }
+        );
+
+        success(`Secret deleted: ${key}`);
+        break;
+      }
+
+      default:
+        error(
+          `Unknown command: ${command}\n\nRun 'lux secrets' to see available commands`
+        );
+    }
+  } catch (err) {
+    const errorMessage =
+      err.response?.data?.error || err.message || 'Unknown error';
+    error(`${errorMessage}`);
+  }
+}
+
+module.exports = { handleSecrets };

package/commands/servers.js

@@ -0,0 +1,411 @@
+const fs = require('fs');
+const path = require('path');
+const net = require('net');
+const chalk = require('chalk');
+const { LUX_STUDIO_DIR } = require('../lib/config');
+
+// Path to the server registry file (written by Lux Studio Electron app)
+const REGISTRY_FILE = path.join(LUX_STUDIO_DIR, 'running-servers.json');
+
+/**
+ * Check if a port is actually in use (server is really running)
+ */
+function isPortInUse(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        resolve(true); // Port is in use
+      } else {
+        resolve(false);
+      }
+    });
+    server.once('listening', () => {
+      server.close();
+      resolve(false); // Port is free, server not running
+    });
+    server.listen(port);
+  });
+}
+
+/**
+ * Load the server registry and verify servers are actually running
+ */
+async function loadRegistry(verifyPorts = false) {
+  if (!fs.existsSync(REGISTRY_FILE)) {
+    return { servers: [], updatedAt: null };
+  }
+
+  try {
+    const content = fs.readFileSync(REGISTRY_FILE, 'utf8');
+    const registry = JSON.parse(content);
+
+    if (verifyPorts && registry.servers && registry.servers.length > 0) {
+      // Verify each server is actually running by checking if port is in use
+      const verifiedServers = [];
+      for (const server of registry.servers) {
+        const isRunning = await isPortInUse(server.port);
+        if (isRunning) {
+          verifiedServers.push(server);
+        }
+      }
+
+      // Update registry if stale servers were found
+      if (verifiedServers.length !== registry.servers.length) {
+        registry.servers = verifiedServers;
+        registry.updatedAt = new Date().toISOString();
+        // Write cleaned registry back
+        try {
+          fs.writeFileSync(REGISTRY_FILE, JSON.stringify(registry, null, 2));
+        } catch {
+          // Ignore write errors
+        }
+      }
+    }
+
+    return registry;
+  } catch (error) {
+    console.error(chalk.red('Error reading server registry:'), error.message);
+    return { servers: [], updatedAt: null };
+  }
+}
+
+/**
+ * List all running servers (verifies ports are actually in use)
+ */
+async function listServers() {
+  // Verify ports to clean up stale entries
+  const registry = await loadRegistry(true);
+
+  if (!registry.servers || registry.servers.length === 0) {
+    console.log(chalk.yellow('\nNo dev servers are currently running.'));
+    console.log(chalk.dim('Start a server in Lux Studio to see it here.\n'));
+    return;
+  }
+
+  console.log(chalk.cyan('\n📡 Running Dev Servers\n'));
+
+  for (const server of registry.servers) {
+    console.log(chalk.white(`  ${server.appName || server.appId}`));
+    console.log(chalk.dim(`    ID:      ${server.appId}`));
+    console.log(chalk.dim(`    Port:    ${server.port}`));
+    console.log(chalk.dim(`    URL:     http://localhost:${server.port}`));
+    console.log(chalk.dim(`    Started: ${formatTime(server.startedAt)}`));
+    if (server.logFile) {
+      console.log(chalk.dim(`    Logs:    ${server.logFile}`));
+    }
+    console.log('');
+  }
+
+  if (registry.updatedAt) {
+    console.log(chalk.dim(`Last updated: ${formatTime(registry.updatedAt)}\n`));
+  }
+}
+
+/**
+ * Get logs for a specific app
+ */
+async function getLogs(appNameOrId, options = {}) {
+  // Verify ports to clean up stale entries
+  const registry = await loadRegistry(true);
+
+  if (!registry.servers || registry.servers.length === 0) {
+    console.log(chalk.yellow('\nNo dev servers are currently running.'));
+    console.log(chalk.dim('Start a server in Lux Studio to see logs.\n'));
+    return;
+  }
+
+  // Find the server by name or ID (case-insensitive partial match)
+  const searchTerm = appNameOrId.toLowerCase();
+  const server = registry.servers.find(s =>
+    s.appId.toLowerCase().includes(searchTerm) ||
+    (s.appName && s.appName.toLowerCase().includes(searchTerm))
+  );
+
+  if (!server) {
+    console.log(chalk.red(`\nNo running server found matching "${appNameOrId}".`));
+    console.log(chalk.dim('\nAvailable servers:'));
+    registry.servers.forEach(s => {
+      console.log(chalk.dim(`  - ${s.appName || s.appId}`));
+    });
+    console.log('');
+    return;
+  }
+
+  if (!server.logFile || !fs.existsSync(server.logFile)) {
+    console.log(chalk.yellow(`\nNo log file found for ${server.appName || server.appId}`));
+    return;
+  }
+
+  // Read and display logs
+  const lines = options.lines || 50;
+  const follow = options.follow || false;
+
+  console.log(chalk.cyan(`\n📝 Logs for ${server.appName || server.appId}`));
+  console.log(chalk.dim(`   Port: ${server.port} | Log file: ${server.logFile}\n`));
+  console.log(chalk.dim('─'.repeat(60)));
+
+  // Read last N lines
+  const content = fs.readFileSync(server.logFile, 'utf8');
+  const allLines = content.split('\n').filter(l => l.trim());
+  const displayLines = allLines.slice(-lines);
+
+  displayLines.forEach(line => {
+    printLogLine(line);
+  });
+
+  console.log(chalk.dim('─'.repeat(60)));
+
+  if (follow) {
+    console.log(chalk.dim('\nWatching for new logs... (Ctrl+C to stop)\n'));
+
+    // Watch the file for changes
+    let lastSize = fs.statSync(server.logFile).size;
+
+    const watcher = fs.watchFile(server.logFile, { interval: 500 }, (curr, prev) => {
+      if (curr.size > lastSize) {
+        // Read new content
+        const fd = fs.openSync(server.logFile, 'r');
+        const buffer = Buffer.alloc(curr.size - lastSize);
+        fs.readSync(fd, buffer, 0, buffer.length, lastSize);
+        fs.closeSync(fd);
+
+        const newContent = buffer.toString('utf8');
+        newContent.split('\n').filter(l => l.trim()).forEach(line => {
+          printLogLine(line);
+        });
+
+        lastSize = curr.size;
+      }
+    });
+
+    // Handle Ctrl+C
+    process.on('SIGINT', () => {
+      fs.unwatchFile(server.logFile);
+      console.log(chalk.dim('\n\nStopped watching logs.\n'));
+      process.exit(0);
+    });
+  } else {
+    console.log(chalk.dim(`\nShowing last ${displayLines.length} lines. Use -f to follow.\n`));
+  }
+}
+
+/**
+ * Print a log line with appropriate coloring
+ */
+function printLogLine(line) {
+  if (line.includes('error') || line.includes('Error') || line.includes('ERROR') || line.includes('❌')) {
+    console.log(chalk.red(line));
+  } else if (line.includes('warn') || line.includes('Warn') || line.includes('WARN') || line.includes('⚠️')) {
+    console.log(chalk.yellow(line));
+  } else if (line.includes('✓') || line.includes('Ready') || line.includes('success')) {
+    console.log(chalk.green(line));
+  } else if (line.includes('[stderr]')) {
+    console.log(chalk.yellow(line));
+  } else {
+    console.log(chalk.dim(line));
+  }
+}
+
+/**
+ * Format a timestamp for display
+ */
+function formatTime(isoString) {
+  if (!isoString) return 'Unknown';
+
+  const date = new Date(isoString);
+  const now = new Date();
+  const diff = now - date;
+
+  // Less than a minute
+  if (diff < 60000) {
+    return 'just now';
+  }
+
+  // Less than an hour
+  if (diff < 3600000) {
+    const mins = Math.floor(diff / 60000);
+    return `${mins} minute${mins === 1 ? '' : 's'} ago`;
+  }
+
+  // Less than a day
+  if (diff < 86400000) {
+    const hours = Math.floor(diff / 3600000);
+    return `${hours} hour${hours === 1 ? '' : 's'} ago`;
+  }
+
+  // Otherwise show date
+  return date.toLocaleString();
+}
+
+/**
+ * Handle the servers command
+ */
+async function handleServers(args = []) {
+  const subcommand = args[0];
+
+  if (!subcommand || subcommand === 'list' || subcommand === 'ls') {
+    await listServers();
+    return;
+  }
+
+  // Show help
+  console.log(chalk.cyan('\nUsage:'));
+  console.log('  lux servers              List all running dev servers');
+  console.log('  lux servers list         List all running dev servers');
+  console.log('');
+}
+
+/**
+ * Get browser console logs for a specific app
+ */
+async function getBrowserConsoleLogs(appNameOrId, options = {}) {
+  const registry = await loadRegistry(true);
+
+  if (!registry.servers || registry.servers.length === 0) {
+    console.log(chalk.yellow('\nNo dev servers are currently running.'));
+    console.log(chalk.dim('Start a server in Lux Studio to see logs.\n'));
+    return;
+  }
+
+  // Find the server by name or ID (case-insensitive partial match)
+  const searchTerm = appNameOrId.toLowerCase();
+  const server = registry.servers.find(s =>
+    s.appId.toLowerCase().includes(searchTerm) ||
+    (s.appName && s.appName.toLowerCase().includes(searchTerm))
+  );
+
+  if (!server) {
+    console.log(chalk.red(`\nNo running server found matching "${appNameOrId}".`));
+    console.log(chalk.dim('\nAvailable servers:'));
+    registry.servers.forEach(s => {
+      console.log(chalk.dim(`  - ${s.appName || s.appId}`));
+    });
+    console.log('');
+    return;
+  }
+
+  // Browser console logs are stored in a separate file
+  const safeAppId = server.appId.replace(/[^a-zA-Z0-9_-]/g, '_');
+  const consoleLogFile = path.join(LUX_STUDIO_DIR, 'logs', `${safeAppId}.console.log`);
+
+  if (!fs.existsSync(consoleLogFile)) {
+    console.log(chalk.yellow(`\nNo browser console logs found for ${server.appName || server.appId}`));
+    console.log(chalk.dim('Interact with your app in the preview to generate console logs.\n'));
+    return;
+  }
+
+  const lines = options.lines || 50;
+  const follow = options.follow || false;
+
+  console.log(chalk.cyan(`\n🖥️  Browser Console Logs for ${server.appName || server.appId}`));
+  console.log(chalk.dim(`   Port: ${server.port} | Log file: ${consoleLogFile}\n`));
+  console.log(chalk.dim('─'.repeat(60)));
+
+  // Read last N lines
+  const content = fs.readFileSync(consoleLogFile, 'utf8');
+  const allLines = content.split('\n').filter(l => l.trim());
+  const displayLines = allLines.slice(-lines);
+
+  displayLines.forEach(line => {
+    printConsoleLine(line);
+  });
+
+  console.log(chalk.dim('─'.repeat(60)));
+
+  if (follow) {
+    console.log(chalk.dim('\nWatching for new logs... (Ctrl+C to stop)\n'));
+
+    let lastSize = fs.statSync(consoleLogFile).size;
+
+    fs.watchFile(consoleLogFile, { interval: 500 }, (curr) => {
+      if (curr.size > lastSize) {
+        const fd = fs.openSync(consoleLogFile, 'r');
+        const buffer = Buffer.alloc(curr.size - lastSize);
+        fs.readSync(fd, buffer, 0, buffer.length, lastSize);
+        fs.closeSync(fd);
+
+        const newContent = buffer.toString('utf8');
+        newContent.split('\n').filter(l => l.trim()).forEach(line => {
+          printConsoleLine(line);
+        });
+
+        lastSize = curr.size;
+      }
+    });
+
+    process.on('SIGINT', () => {
+      fs.unwatchFile(consoleLogFile);
+      console.log(chalk.dim('\n\nStopped watching logs.\n'));
+      process.exit(0);
+    });
+  } else {
+    console.log(chalk.dim(`\nShowing last ${displayLines.length} lines. Use -f to follow.\n`));
+  }
+}
+
+/**
+ * Print a browser console log line with level-based coloring
+ */
+function printConsoleLine(line) {
+  // Format: [timestamp] [LEVEL] message
+  if (line.includes('[ERROR]')) {
+    console.log(chalk.red(line));
+  } else if (line.includes('[WARN]')) {
+    console.log(chalk.yellow(line));
+  } else if (line.includes('[INFO]')) {
+    console.log(chalk.blue(line));
+  } else if (line.includes('[DEBUG]')) {
+    console.log(chalk.dim(line));
+  } else {
+    console.log(chalk.white(line));
+  }
+}
+
+/**
+ * Handle the logs command
+ */
+async function handleLogs(args = [], options = {}) {
+  if (args.length === 0) {
+    // No app specified - show help or list servers
+    const registry = await loadRegistry(true);
+
+    if (!registry.servers || registry.servers.length === 0) {
+      console.log(chalk.yellow('\nNo dev servers are currently running.'));
+      return;
+    }
+
+    if (registry.servers.length === 1) {
+      // Only one server, show its logs
+      if (options.console) {
+        await getBrowserConsoleLogs(registry.servers[0].appId, options);
+      } else {
+        await getLogs(registry.servers[0].appId, options);
+      }
+      return;
+    }
+
+    // Multiple servers - ask user to specify
+    console.log(chalk.cyan('\nMultiple servers running. Specify which app:\n'));
+    registry.servers.forEach(s => {
+      console.log(chalk.white(`  lux logs ${s.appName || s.appId}`));
+    });
+    console.log('');
+    return;
+  }
+
+  const appNameOrId = args[0];
+  if (options.console) {
+    await getBrowserConsoleLogs(appNameOrId, options);
+  } else {
+    await getLogs(appNameOrId, options);
+  }
+}
+
+module.exports = {
+  handleServers,
+  handleLogs,
+  listServers,
+  getLogs,
+  getBrowserConsoleLogs,
+};

package/commands/storage.js

@@ -0,0 +1,177 @@
+const axios = require('axios');
+const chalk = require('chalk');
+const fs = require('fs');
+const {
+  getApiUrl,
+  getAuthHeaders,
+  isAuthenticated,
+  loadInterfaceConfig,
+} = require('../lib/config');
+const {
+  error,
+  success,
+  info,
+  formatTable,
+  formatSize,
+  formatDate,
+  requireArgs,
+} = require('../lib/helpers');
+
+async function handleStorage(args) {
+  // Check authentication
+  if (!isAuthenticated()) {
+    console.log(
+      chalk.red('❌ Not authenticated. Run'),
+      chalk.white('lux login'),
+      chalk.red('first.')
+    );
+    process.exit(1);
+  }
+
+  const command = args[0];
+
+  if (!command) {
+    console.log(`
+${chalk.bold('Usage:')} lux storage <command> [args]
+
+${chalk.bold('Commands:')}
+  ls [prefix]              List files in R2 bucket
+  get <key> [output-file]  Download file from R2
+  put <key> <file>         Upload file to R2
+  rm <key>                 Delete file from R2
+
+${chalk.bold('Examples:')}
+  lux storage ls workflows/
+  lux storage get workflows/flow_123/draft-config.json
+  lux storage put workflows/flow_123/config.json ./local-config.json
+  lux storage rm workflows/flow_123/old-config.json
+`);
+    process.exit(0);
+  }
+
+  const apiUrl = getApiUrl();
+
+  try {
+    switch (command) {
+      case 'ls': {
+        const prefix = args[1] || '';
+        info(
+          prefix ? `Listing files with prefix: ${prefix}` : 'Listing all files...'
+        );
+
+        // Use files API to list files
+        const { data } = await axios.get(`${apiUrl}/api/files`, {
+          headers: getAuthHeaders(),
+          params: prefix ? { prefix } : {},
+        });
+
+        if (!data.files || data.files.length === 0) {
+          console.log('\n(No files found)\n');
+        } else {
+          console.log(`\nFound ${data.files.length} file(s):\n`);
+          const formatted = data.files.map((f) => ({
+            key: f.key || f.name,
+            size: formatSize(f.size || 0),
+            lastModified: formatDate(f.lastModified || f.updated_at),
+          }));
+          formatTable(formatted);
+          console.log('');
+        }
+        break;
+      }
+
+      case 'get': {
+        requireArgs(args.slice(1), 1, 'lux storage get <key> [output-file]');
+        const key = args[1];
+        const outputPath = args[2];
+
+        info(`Downloading: ${key}`);
+
+        // Get download URL
+        const { data } = await axios.get(`${apiUrl}/api/files/${encodeURIComponent(key)}`, {
+          headers: getAuthHeaders(),
+        });
+
+        if (!data.url) {
+          error('Failed to get download URL');
+        }
+
+        // Download file
+        const response = await axios.get(data.url, {
+          responseType: 'arraybuffer',
+        });
+
+        if (outputPath) {
+          fs.writeFileSync(outputPath, response.data);
+          success(
+            `Downloaded to: ${outputPath} (${formatSize(response.data.length)})`
+          );
+        } else {
+          console.log(response.data.toString('utf-8'));
+        }
+        break;
+      }
+
+      case 'put': {
+        requireArgs(args.slice(1), 2, 'lux storage put <key> <file>');
+        const key = args[1];
+        const filePath = args[2];
+
+        if (!fs.existsSync(filePath)) {
+          error(`File not found: ${filePath}`);
+        }
+
+        info(`Uploading: ${key}`);
+
+        const fileBuffer = fs.readFileSync(filePath);
+
+        // Get upload URL
+        const interfaceConfig = loadInterfaceConfig();
+        if (!interfaceConfig || !interfaceConfig.id) {
+          error('No interface found. This command requires an interface context.');
+        }
+
+        const { data: uploadData } = await axios.post(
+          `${apiUrl}/api/interfaces/${interfaceConfig.id}/presigned-urls`,
+          { action: 'upload' },
+          { headers: getAuthHeaders() }
+        );
+
+        // Upload to R2
+        await axios.put(uploadData.uploadUrl, fileBuffer, {
+          headers: {
+            'Content-Type': 'application/octet-stream',
+          },
+        });
+
+        success(`Uploaded: ${key} (${formatSize(fileBuffer.length)})`);
+        break;
+      }
+
+      case 'rm': {
+        requireArgs(args.slice(1), 1, 'lux storage rm <key>');
+        const key = args[1];
+
+        info(`Deleting: ${key}`);
+
+        await axios.delete(`${apiUrl}/api/files/${encodeURIComponent(key)}`, {
+          headers: getAuthHeaders(),
+        });
+
+        success(`Deleted: ${key}`);
+        break;
+      }
+
+      default:
+        error(
+          `Unknown command: ${command}\n\nRun 'lux storage' to see available commands`
+        );
+    }
+  } catch (err) {
+    const errorMessage =
+      err.response?.data?.error || err.message || 'Unknown error';
+    error(`${errorMessage}`);
+  }
+}
+
+module.exports = { handleStorage };