luxlabs 1.0.0

package/commands/dev.js

@@ -0,0 +1,569 @@
+const { spawn, execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+const chalk = require('chalk');
+const axios = require('axios');
+const chokidar = require('chokidar');
+const {
+  loadConfig,
+  loadInterfaceConfig,
+  getDashboardUrl,
+  getAuthHeaders,
+  isAuthenticated,
+  LUX_STUDIO_DIR,
+} = require('../lib/config');
+const { info, warn, error, success } = require('../lib/helpers');
+const { getNodePath, getNpmPath, getNodeEnv, isBundledNodeAvailable } = require('../lib/node-helper');
+
+// Cloudflared binary paths
+const CLOUDFLARED_DIR = path.join(LUX_STUDIO_DIR, 'bin');
+const CLOUDFLARED_PATH = path.join(
+  CLOUDFLARED_DIR,
+  process.platform === 'win32' ? 'cloudflared.exe' : 'cloudflared'
+);
+
+// Download URLs for cloudflared
+const CLOUDFLARED_URLS = {
+  darwin: {
+    arm64:
+      'https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-darwin-arm64.tgz',
+    x64: 'https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-darwin-amd64.tgz',
+  },
+  linux: {
+    arm64:
+      'https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-arm64',
+    x64: 'https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64',
+  },
+  win32: {
+    x64: 'https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-amd64.exe',
+  },
+};
+
+// State
+let devServerProcess = null;
+let tunnelProcess = null;
+let syncWatcher = null;
+let heartbeatInterval = null;
+let tunnelUrl = null;
+let isShuttingDown = false;
+
+/**
+ * Main dev command
+ */
+async function dev(options = {}) {
+  const port = options.port || 3000;
+  const noTunnel = options.noTunnel || false;
+  const noSync = options.noSync || false;
+
+  console.log(chalk.cyan('\n🚀 Lux Dev Server\n'));
+
+  // Check authentication
+  if (!isAuthenticated()) {
+    console.log(
+      chalk.red('❌ Not authenticated. Run'),
+      chalk.white('lux login'),
+      chalk.red('first.')
+    );
+    process.exit(1);
+  }
+
+  // Check if this is a Lux interface
+  const interfaceConfig = loadInterfaceConfig();
+  if (!interfaceConfig) {
+    console.log(
+      chalk.yellow('⚠️  No .lux/interface.json found.'),
+      chalk.dim('Run'),
+      chalk.white('lux init'),
+      chalk.dim('first, or run from an interface directory.')
+    );
+    process.exit(1);
+  }
+
+  // Check for package.json
+  if (!fs.existsSync('package.json')) {
+    console.log(chalk.red('❌ No package.json found in current directory.'));
+    process.exit(1);
+  }
+
+  // Setup graceful shutdown
+  setupShutdownHandlers();
+
+  try {
+    // Step 1: Check/install dependencies
+    await checkDependencies();
+
+    // Step 2: Start Next.js dev server
+    await startDevServer(port);
+
+    // Step 3: Start tunnel (unless disabled)
+    if (!noTunnel) {
+      await startTunnel(port);
+
+      // Step 4: Register tunnel with Lux cloud
+      if (tunnelUrl && interfaceConfig.id) {
+        await registerTunnel(interfaceConfig.id, tunnelUrl);
+
+        // Step 4b: Start heartbeat to keep tunnel alive
+        startHeartbeat(interfaceConfig.id);
+      }
+    }
+
+    // Step 5: Start file sync (unless disabled)
+    if (!noSync && interfaceConfig.githubRepoUrl) {
+      startFileSync();
+    }
+
+    // Print status
+    printStatus(port, noTunnel, noSync, interfaceConfig);
+  } catch (err) {
+    console.error(chalk.red('\n❌ Failed to start dev server:'), err.message);
+    await cleanup();
+    process.exit(1);
+  }
+}
+
+/**
+ * Check and install npm dependencies if needed
+ */
+async function checkDependencies() {
+  const nodeModulesExists = fs.existsSync('node_modules');
+  const nextBinExists = fs.existsSync('./node_modules/.bin/next');
+
+  if (!nodeModulesExists || !nextBinExists) {
+    console.log(chalk.yellow('📦 Installing dependencies...'));
+    try {
+      const npmPath = getNpmPath();
+      const nodeEnv = getNodeEnv();
+
+      // Use bundled npm if available
+      if (isBundledNodeAvailable()) {
+        execSync(`"${npmPath}" install`, { stdio: 'inherit', env: nodeEnv });
+      } else {
+        execSync('npm install', { stdio: 'inherit' });
+      }
+      console.log(chalk.green('✓ Dependencies installed\n'));
+    } catch (err) {
+      throw new Error('npm install failed');
+    }
+  }
+}
+
+/**
+ * Start the Next.js dev server
+ */
+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 nodePath = getNodePath();
+    const nodeEnv = getNodeEnv();
+
+    // Use bundled Node.js to run Next.js dev server
+    devServerProcess = spawn(nodePath, [nextBin, 'dev', '-p', String(port)], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...nodeEnv, FORCE_COLOR: '1' },
+    });
+
+    let started = false;
+
+    devServerProcess.stdout.on('data', (data) => {
+      const output = data.toString();
+      process.stdout.write(chalk.dim(output));
+
+      // Detect when server is ready
+      if (!started && (output.includes('Ready') || output.includes('started'))) {
+        started = true;
+        console.log(chalk.green(`\n✓ Dev server running on http://localhost:${port}\n`));
+        resolve();
+      }
+    });
+
+    devServerProcess.stderr.on('data', (data) => {
+      const output = data.toString();
+      // Filter out noisy warnings
+      if (!output.includes('ExperimentalWarning')) {
+        process.stderr.write(chalk.yellow(output));
+      }
+    });
+
+    devServerProcess.on('error', (err) => {
+      reject(new Error(`Failed to start dev server: ${err.message}`));
+    });
+
+    devServerProcess.on('exit', (code) => {
+      if (!isShuttingDown && code !== 0) {
+        console.error(chalk.red(`\nDev server exited with code ${code}`));
+      }
+    });
+
+    // Timeout for server start
+    setTimeout(() => {
+      if (!started) {
+        started = true;
+        console.log(chalk.yellow('\n⚠️  Server may still be starting...\n'));
+        resolve();
+      }
+    }, 30000);
+  });
+}
+
+/**
+ * Download cloudflared if not present
+ */
+async function ensureCloudflared() {
+  if (fs.existsSync(CLOUDFLARED_PATH)) {
+    return;
+  }
+
+  console.log(chalk.dim('Downloading cloudflared tunnel client...'));
+
+  // Create bin directory
+  if (!fs.existsSync(CLOUDFLARED_DIR)) {
+    fs.mkdirSync(CLOUDFLARED_DIR, { recursive: true });
+  }
+
+  const platform = process.platform;
+  const arch = process.arch === 'arm64' ? 'arm64' : 'x64';
+
+  const urls = CLOUDFLARED_URLS[platform];
+  if (!urls || !urls[arch]) {
+    throw new Error(
+      `Unsupported platform: ${platform}/${arch}. Please install cloudflared manually.`
+    );
+  }
+
+  const url = urls[arch];
+
+  return new Promise((resolve, reject) => {
+    const downloadFile = (downloadUrl, destPath, callback) => {
+      const file = fs.createWriteStream(destPath);
+
+      https
+        .get(downloadUrl, (response) => {
+          // Handle redirects
+          if (response.statusCode === 302 || response.statusCode === 301) {
+            downloadFile(response.headers.location, destPath, callback);
+            return;
+          }
+
+          response.pipe(file);
+          file.on('finish', () => {
+            file.close(callback);
+          });
+        })
+        .on('error', (err) => {
+          fs.unlink(destPath, () => {});
+          reject(err);
+        });
+    };
+
+    const isTarball = url.endsWith('.tgz');
+    const downloadPath = isTarball
+      ? path.join(CLOUDFLARED_DIR, 'cloudflared.tgz')
+      : CLOUDFLARED_PATH;
+
+    downloadFile(url, downloadPath, async () => {
+      try {
+        if (isTarball) {
+          // Extract tarball (macOS)
+          execSync(`tar -xzf "${downloadPath}" -C "${CLOUDFLARED_DIR}"`, {
+            stdio: 'ignore',
+          });
+          fs.unlinkSync(downloadPath);
+        }
+
+        // Make executable
+        if (platform !== 'win32') {
+          fs.chmodSync(CLOUDFLARED_PATH, '755');
+        }
+
+        console.log(chalk.green('✓ cloudflared installed\n'));
+        resolve();
+      } catch (err) {
+        reject(new Error(`Failed to setup cloudflared: ${err.message}`));
+      }
+    });
+  });
+}
+
+/**
+ * Start cloudflare tunnel
+ */
+async function startTunnel(port) {
+  await ensureCloudflared();
+
+  return new Promise((resolve, reject) => {
+    console.log(chalk.dim('Starting tunnel...'));
+
+    tunnelProcess = spawn(CLOUDFLARED_PATH, [
+      'tunnel',
+      '--url',
+      `http://localhost:${port}`,
+      '--no-autoupdate',
+    ]);
+
+    let resolved = false;
+
+    tunnelProcess.stderr.on('data', (data) => {
+      const output = data.toString();
+
+      // Extract tunnel URL from output
+      const urlMatch = output.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
+      if (urlMatch && !resolved) {
+        tunnelUrl = urlMatch[0];
+        resolved = true;
+        console.log(chalk.green(`✓ Tunnel active: ${chalk.cyan(tunnelUrl)}\n`));
+        resolve();
+      }
+
+      // Debug output (only show errors)
+      if (output.includes('ERR') || output.includes('error')) {
+        console.error(chalk.red(output));
+      }
+    });
+
+    tunnelProcess.on('error', (err) => {
+      reject(new Error(`Failed to start tunnel: ${err.message}`));
+    });
+
+    tunnelProcess.on('exit', (code) => {
+      if (!isShuttingDown && code !== 0) {
+        console.error(chalk.red(`\nTunnel exited with code ${code}`));
+      }
+    });
+
+    // Timeout
+    setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        console.log(chalk.yellow('\n⚠️  Tunnel may still be connecting...\n'));
+        resolve();
+      }
+    }, 30000);
+  });
+}
+
+/**
+ * Register tunnel URL with Lux cloud (dashboard)
+ */
+async function registerTunnel(interfaceId, url) {
+  try {
+    const dashboardUrl = getDashboardUrl();
+    const headers = getAuthHeaders();
+
+    await axios.post(
+      `${dashboardUrl}/api/tunnel/register`,
+      {
+        interface_id: interfaceId,
+        tunnel_url: url,
+      },
+      { headers }
+    );
+
+    console.log(chalk.green('✓ Tunnel registered with Lux cloud\n'));
+  } catch (err) {
+    console.log(
+      chalk.yellow('⚠️  Could not register tunnel with cloud:'),
+      err.response?.data?.error || err.message
+    );
+    console.log(chalk.dim('Preview in dashboard may not work.\n'));
+  }
+}
+
+/**
+ * Unregister tunnel when shutting down
+ */
+async function unregisterTunnel(interfaceId) {
+  try {
+    const dashboardUrl = getDashboardUrl();
+    const headers = getAuthHeaders();
+
+    await axios.post(
+      `${dashboardUrl}/api/tunnel/unregister`,
+      { interface_id: interfaceId },
+      { headers, timeout: 3000 }
+    );
+  } catch (err) {
+    // Ignore errors during shutdown
+  }
+}
+
+/**
+ * Start heartbeat to keep tunnel alive
+ */
+function startHeartbeat(interfaceId) {
+  const dashboardUrl = getDashboardUrl();
+  const headers = getAuthHeaders();
+
+  // Send heartbeat every 30 seconds
+  heartbeatInterval = setInterval(async () => {
+    try {
+      await axios.post(
+        `${dashboardUrl}/api/tunnel/heartbeat`,
+        { interface_id: interfaceId },
+        { headers, timeout: 5000 }
+      );
+    } catch (err) {
+      // Silently ignore heartbeat failures
+      // The tunnel will be marked stale after 2 minutes without heartbeat
+    }
+  }, 30000);
+
+  // Send initial heartbeat
+  axios.post(
+    `${dashboardUrl}/api/tunnel/heartbeat`,
+    { interface_id: interfaceId },
+    { headers, timeout: 5000 }
+  ).catch(() => {});
+}
+
+/**
+ * Start file watcher for GitHub sync
+ */
+function startFileSync() {
+  console.log(chalk.dim('Starting file sync...\n'));
+
+  // Debounce sync operations
+  let syncTimeout = null;
+  const pendingChanges = new Set();
+
+  const doSync = () => {
+    if (pendingChanges.size === 0) return;
+
+    const changes = Array.from(pendingChanges);
+    pendingChanges.clear();
+
+    console.log(chalk.dim(`Syncing ${changes.length} file(s) to GitHub...`));
+
+    try {
+      // Add all changes
+      execSync('git add -A', { stdio: 'ignore' });
+
+      // Check if there are changes to commit
+      const status = execSync('git status --porcelain').toString();
+      if (status.trim()) {
+        // Commit with auto message
+        const message = `Auto-sync: ${changes.slice(0, 3).join(', ')}${changes.length > 3 ? ` +${changes.length - 3} more` : ''}`;
+        execSync(`git commit -m "${message}"`, { stdio: 'ignore' });
+
+        // Push to dev branch
+        execSync('git push origin dev', { stdio: 'ignore' });
+
+        console.log(chalk.green('✓ Synced to GitHub\n'));
+      }
+    } catch (err) {
+      console.log(chalk.yellow('⚠️  Sync failed:'), err.message);
+    }
+  };
+
+  // Watch for file changes
+  syncWatcher = chokidar.watch('.', {
+    ignored: [
+      /node_modules/,
+      /\.next/,
+      /\.git/,
+      /\.lux/,
+      /\.DS_Store/,
+    ],
+    ignoreInitial: true,
+    persistent: true,
+  });
+
+  syncWatcher.on('all', (event, filePath) => {
+    pendingChanges.add(filePath);
+
+    // Debounce: sync after 5 seconds of no changes
+    clearTimeout(syncTimeout);
+    syncTimeout = setTimeout(doSync, 5000);
+  });
+
+  console.log(chalk.green('✓ File sync active (auto-commits to GitHub)\n'));
+}
+
+/**
+ * Print final status
+ */
+function printStatus(port, noTunnel, noSync, interfaceConfig) {
+  console.log(chalk.cyan('─'.repeat(50)));
+  console.log(chalk.cyan.bold('\n📍 Dev Server Status\n'));
+
+  console.log(chalk.white('  Local:'), `http://localhost:${port}`);
+
+  if (!noTunnel && tunnelUrl) {
+    console.log(chalk.white('  Tunnel:'), chalk.cyan(tunnelUrl));
+    console.log(chalk.white('  Preview:'), chalk.dim('Available in Lux dashboard'));
+  }
+
+  if (!noSync) {
+    console.log(chalk.white('  Sync:'), chalk.green('Active'), chalk.dim('(auto-push to GitHub)'));
+  }
+
+  console.log(chalk.white('  Interface:'), interfaceConfig.name || interfaceConfig.id);
+
+  console.log(chalk.cyan('\n─'.repeat(50)));
+  console.log(chalk.dim('\nPress Ctrl+C to stop\n'));
+}
+
+/**
+ * Setup graceful shutdown handlers
+ */
+function setupShutdownHandlers() {
+  const shutdown = async (signal) => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+
+    console.log(chalk.yellow(`\n\nReceived ${signal}, shutting down...\n`));
+
+    await cleanup();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+  process.on('SIGHUP', () => shutdown('SIGHUP'));
+}
+
+/**
+ * Cleanup all processes
+ */
+async function cleanup() {
+  const interfaceConfig = loadInterfaceConfig();
+
+  // Stop heartbeat
+  if (heartbeatInterval) {
+    clearInterval(heartbeatInterval);
+    console.log(chalk.dim('Stopped heartbeat'));
+  }
+
+  // Unregister tunnel
+  if (interfaceConfig?.id) {
+    await unregisterTunnel(interfaceConfig.id);
+  }
+
+  // Stop file watcher
+  if (syncWatcher) {
+    await syncWatcher.close();
+    console.log(chalk.dim('Stopped file sync'));
+  }
+
+  // Stop tunnel
+  if (tunnelProcess) {
+    tunnelProcess.kill();
+    console.log(chalk.dim('Stopped tunnel'));
+  }
+
+  // Stop dev server
+  if (devServerProcess) {
+    devServerProcess.kill();
+    console.log(chalk.dim('Stopped dev server'));
+  }
+
+  console.log(chalk.green('\n✓ Shutdown complete\n'));
+}
+
+module.exports = {
+  dev,
+};

package/commands/init.js

@@ -0,0 +1,126 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const fs = require('fs');
+const { saveInterfaceConfig, loadInterfaceConfig } = require('../lib/config');
+
+async function init(options) {
+  console.log(chalk.cyan('\n📦 Initialize Lux Interface\n'));
+
+  // Check if already initialized
+  const existing = loadInterfaceConfig();
+  if (existing) {
+    console.log(
+      chalk.yellow(
+        '⚠️  This directory is already initialized as a Lux interface.'
+      )
+    );
+    console.log(chalk.dim(`Interface: ${existing.name} (${existing.id})\n`));
+
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'overwrite',
+        message: 'Do you want to reinitialize?',
+        default: false,
+      },
+    ]);
+
+    if (!overwrite) {
+      console.log(chalk.dim('Cancelled.'));
+      return;
+    }
+  }
+
+  // Get interface details
+  let answers;
+
+  // If name is provided via flags, skip interactive prompts
+  if (options.name) {
+    answers = {
+      name: options.name,
+      description: options.description || '',
+    };
+    console.log(chalk.dim(`Name: ${answers.name}`));
+    if (answers.description) {
+      console.log(chalk.dim(`Description: ${answers.description}`));
+    }
+  } else {
+    // Interactive prompts
+    answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'name',
+        message: 'Interface name:',
+        default: options.name || require('path').basename(process.cwd()),
+        validate: (input) => {
+          if (!input || input.trim().length === 0) {
+            return 'Interface name is required';
+          }
+          return true;
+        },
+      },
+      {
+        type: 'input',
+        name: 'description',
+        message: 'Description (optional):',
+        default: options.description || '',
+      },
+    ]);
+  }
+
+  // Create interface config
+  const config = {
+    name: answers.name,
+    description: answers.description,
+    createdAt: new Date().toISOString(),
+  };
+
+  // Save config
+  saveInterfaceConfig(config);
+
+  console.log(chalk.green('\n✓ Interface initialized successfully!\n'));
+  console.log(chalk.dim('Configuration saved to .lux/interface.json\n'));
+  console.log(chalk.cyan('Next steps:'));
+  console.log(
+    chalk.dim('  1. Run'),
+    chalk.white('lux up'),
+    chalk.dim('to upload your code')
+  );
+  console.log(
+    chalk.dim('  2. Run'),
+    chalk.white('lux deploy'),
+    chalk.dim('to deploy to production\n')
+  );
+
+  // Create .gitignore entry if needed
+  addToGitignore();
+}
+
+function addToGitignore() {
+  const gitignorePath = '.gitignore';
+  const entry = '.lux/interface.json';
+
+  if (fs.existsSync(gitignorePath)) {
+    const content = fs.readFileSync(gitignorePath, 'utf8');
+
+    if (!content.includes(entry)) {
+      const { confirm } = require('inquirer').prompt([
+        {
+          type: 'confirm',
+          name: 'confirm',
+          message: 'Add .lux/interface.json to .gitignore?',
+          default: true,
+        },
+      ]);
+
+      if (confirm) {
+        fs.appendFileSync(gitignorePath, `\n# Lux CLI\n${entry}\n`);
+        console.log(chalk.dim('✓ Added to .gitignore'));
+      }
+    }
+  }
+}
+
+module.exports = {
+  init,
+};