luxlabs 1.0.0

package/commands/interface/boilerplate.js

@@ -0,0 +1,52 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Get the templates directory path
+ * Uses the canonical templates directory at project root (single source of truth)
+ */
+function getTemplatesDir() {
+  return path.join(__dirname, '../../../../templates/interface-boilerplate');
+}
+
+/**
+ * Recursively copy a directory
+ */
+function copyDirRecursive(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Create boilerplate files in a directory
+ * Copies from the templates/ directory
+ */
+function writeBoilerplateFiles(targetDir) {
+  const templatesDir = getTemplatesDir();
+
+  if (!fs.existsSync(templatesDir)) {
+    throw new Error(`Templates directory not found at ${templatesDir}`);
+  }
+
+  copyDirRecursive(templatesDir, targetDir);
+}
+
+module.exports = {
+  getTemplatesDir,
+  copyDirRecursive,
+  writeBoilerplateFiles,
+};

package/commands/interface/git-utils.js

@@ -0,0 +1,85 @@
+const { spawn } = require('child_process');
+const fs = require('fs');
+
+/**
+ * Run a git command and return a promise
+ */
+function runGitCommand(args, cwd, timeoutMs = 60000) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('git', args, { cwd, stdio: 'pipe' });
+
+    let stderr = '';
+    proc.stdout?.on('data', () => {}); // Consume stdout to prevent buffer deadlock
+    proc.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`git ${args[0]} failed with code ${code}: ${stderr}`));
+      }
+    });
+
+    proc.on('error', reject);
+
+    const timeout = setTimeout(() => {
+      proc.kill();
+      reject(new Error(`git ${args[0]} timed out`));
+    }, timeoutMs);
+
+    proc.on('close', () => clearTimeout(timeout));
+  });
+}
+
+/**
+ * Clone a git repository with retry logic
+ */
+async function cloneRepoWithRetry(url, targetDir, maxRetries = 5) {
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      await new Promise((resolve, reject) => {
+        const cloneProc = spawn('git', ['clone', url, targetDir], { stdio: 'pipe' });
+
+        let stderr = '';
+        cloneProc.stdout?.on('data', () => {}); // Consume stdout to prevent buffer deadlock
+        cloneProc.stderr?.on('data', (data) => {
+          stderr += data.toString();
+        });
+
+        cloneProc.on('close', (code) => {
+          if (code === 0) {
+            resolve();
+          } else {
+            reject(new Error(`Git clone failed with code ${code}: ${stderr}`));
+          }
+        });
+
+        cloneProc.on('error', reject);
+
+        // Timeout after 60 seconds
+        setTimeout(() => reject(new Error('Git clone timed out')), 60000);
+      });
+
+      return true; // Success
+    } catch (err) {
+      if (attempt < maxRetries) {
+        const delay = attempt * 2000; // 2s, 4s, 6s, 8s
+        await new Promise(r => setTimeout(r, delay));
+
+        // Clean up failed clone directory
+        if (fs.existsSync(targetDir)) {
+          fs.rmSync(targetDir, { recursive: true, force: true });
+        }
+      } else {
+        throw err; // All retries exhausted
+      }
+    }
+  }
+}
+
+module.exports = {
+  runGitCommand,
+  cloneRepoWithRetry,
+};

package/commands/interface/index.js

@@ -0,0 +1,7 @@
+// Re-export all interface modules
+module.exports = {
+  ...require('./git-utils'),
+  ...require('./boilerplate'),
+  ...require('./init'),
+  ...require('./path'),
+};

package/commands/interface/init.js

@@ -0,0 +1,375 @@
+const axios = require('axios');
+const chalk = require('chalk');
+const ora = require('ora');
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const {
+  getStudioApiUrl,
+  getAuthHeaders,
+  isAuthenticated,
+  getInterfaceRepoDir,
+  ensureInterfaceDir,
+  interfaceExists,
+  saveInterfaceMetadata,
+  loadConfig,
+  slugify,
+} = require('../../lib/config');
+const { runGitCommand } = require('./git-utils');
+const { writeBoilerplateFiles } = require('./boilerplate');
+const { getNpmPath, getNodeEnv } = require('../../lib/node-helper');
+
+/**
+ * Run npm install with optimized flags using bundled Node.js
+ */
+function runNpmInstall(cwd) {
+  return new Promise((resolve, reject) => {
+    const npmPath = getNpmPath();
+    const nodeEnv = getNodeEnv();
+
+    const npmProc = spawn(npmPath, ['install', '--prefer-offline', '--no-audit', '--no-fund'], {
+      cwd,
+      stdio: 'pipe',
+      shell: process.platform === 'win32',
+      env: nodeEnv,
+    });
+
+    npmProc.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`npm install exited with code ${code}`));
+    });
+
+    npmProc.on('error', reject);
+
+    // Timeout after 3 minutes
+    setTimeout(() => reject(new Error('npm install timed out')), 3 * 60 * 1000);
+  });
+}
+
+/**
+ * Initialize local repo and push to GitHub
+ */
+async function initAndPushToGitHub(repoDir, githubRepoUrl, githubToken) {
+  const targetUrl = githubRepoUrl.replace('https://github.com/', `https://${githubToken}@github.com/`) + '.git';
+
+  // Initialize git repo
+  await runGitCommand(['init'], repoDir);
+  await runGitCommand(['add', '.'], repoDir);
+  await runGitCommand(['commit', '-m', 'Initial commit from Lux'], repoDir);
+
+  // Add remote and push to main
+  await runGitCommand(['remote', 'add', 'origin', targetUrl], repoDir);
+  await runGitCommand(['branch', '-M', 'main'], repoDir);
+  await runGitCommand(['push', '-u', 'origin', 'main', '--force'], repoDir);
+
+  // Remove .git directory after push (we don't want nested git repos)
+  const gitDir = path.join(repoDir, '.git');
+  if (fs.existsSync(gitDir)) {
+    fs.rmSync(gitDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Initialize a new interface with boilerplate code
+ * Creates git repo, package.json, and registers in system.interfaces table
+ */
+async function initInterface(options) {
+  // Check authentication
+  if (!isAuthenticated()) {
+    console.log(
+      chalk.red('❌ Not authenticated. Run'),
+      chalk.white('lux login'),
+      chalk.red('first.')
+    );
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan('\n📦 Initialize New App\n'));
+  console.log(chalk.dim('─'.repeat(50)));
+  console.log(chalk.blue('[STEP 0/6]'), 'Validating options...');
+
+  // Get interface details from flags (non-interactive)
+  let name = options.name;
+  let description = options.description || '';
+
+  if (!name) {
+    console.log(chalk.red('❌ --name flag is required'));
+    console.log(chalk.dim('Usage: lux i init --name <name> [--description <desc>]'));
+    process.exit(1);
+  }
+
+  // Slugify the name for folder
+  const slug = slugify(name);
+  console.log(chalk.dim('  Name:'), name);
+  console.log(chalk.dim('  Slug:'), slug);
+
+  // Check if interface with this slug already exists
+  if (interfaceExists(slug)) {
+    console.log(chalk.red(`❌ Interface already exists: ${slug}`));
+    console.log(chalk.dim('Use a different name or delete the existing interface first.'));
+    process.exit(1);
+  }
+
+  console.log(chalk.green('  ✓ Options validated'));
+  console.log(chalk.dim('─'.repeat(50)));
+
+  try {
+    const apiUrl = getStudioApiUrl();
+
+    // STEP 1: Create interface via API (registers in system.interfaces + creates GitHub repo)
+    console.log(chalk.blue('[STEP 1/6]'), 'Creating interface via API...');
+    console.log(chalk.dim('  API URL:'), apiUrl);
+    console.log(chalk.dim('  Endpoint:'), '/api/interfaces');
+
+    const { data } = await axios.post(
+      `${apiUrl}/api/interfaces`,
+      {
+        name,
+        description,
+      },
+      {
+        headers: getAuthHeaders(),
+      }
+    );
+
+    const interfaceData = data.interface || data;
+    const interfaceId = interfaceData.id;  // UUID from API - stored in metadata
+    const githubRepoUrl = interfaceData.github_repo_url;
+    const vercelProjectId = interfaceData.vercel_project_id;
+    const vercelProjectUrl = interfaceData.vercel_project_url;
+
+    console.log(chalk.green('  ✓ Interface registered in database'));
+    console.log(chalk.dim('  Interface ID:'), interfaceId);
+    if (githubRepoUrl) {
+      console.log(chalk.green('  ✓ GitHub repository created'));
+      console.log(chalk.dim('  GitHub URL:'), githubRepoUrl);
+    } else {
+      console.log(chalk.yellow('  ⚠ No GitHub repository URL returned'));
+    }
+
+    if (vercelProjectId) {
+      console.log(chalk.green('  ✓ Vercel project created'));
+      console.log(chalk.dim('  Vercel Project ID:'), vercelProjectId);
+      if (vercelProjectUrl) {
+        console.log(chalk.dim('  Vercel Dashboard:'), vercelProjectUrl);
+      }
+    } else {
+      console.log(chalk.yellow('  ⚠ Vercel project not created (may need VERCEL_TOKEN)'));
+    }
+
+    // Output parseable format for API wrapper
+    console.log(`App created: ${interfaceId}`);
+    if (githubRepoUrl) {
+      console.log(`GitHub repo: ${githubRepoUrl}`);
+    }
+    if (vercelProjectId) {
+      console.log(`Vercel project: ${vercelProjectId}`);
+    }
+    console.log(chalk.dim('─'.repeat(50)));
+
+    // Set up local files and push to GitHub
+    if (githubRepoUrl) {
+      // STEP 2: Get GitHub token
+      console.log(chalk.blue('[STEP 2/6]'), 'Fetching GitHub token...');
+      const config = loadConfig();
+      let githubToken = config?.githubPat;
+
+      // If no local githubPat, fetch from API
+      if (!githubToken) {
+        console.log(chalk.dim('  No local token, fetching from API...'));
+        try {
+          const tokenRes = await axios.get(`${apiUrl}/api/studio/github-token`, {
+            headers: getAuthHeaders(),
+          });
+          if (tokenRes.data?.token) {
+            githubToken = tokenRes.data.token;
+            console.log(chalk.green('  ✓ GitHub token fetched from API'));
+          } else {
+            console.log(chalk.yellow('  ⚠ No token returned from API'));
+          }
+        } catch (tokenErr) {
+          console.log(chalk.yellow('  ⚠ Failed to fetch token:'), tokenErr.message);
+        }
+      } else {
+        console.log(chalk.green('  ✓ Using local GitHub token'));
+      }
+      console.log(chalk.dim('─'.repeat(50)));
+
+      // STEP 3: Create interface directory and copy template files
+      console.log(chalk.blue('[STEP 3/6]'), 'Copying template files...');
+      try {
+        const interfaceDir = ensureInterfaceDir(interfaceId);
+        if (!interfaceDir) {
+          throw new Error('Could not create interface directory (not authenticated or no org ID)');
+        }
+        console.log(chalk.dim('  Interface dir:'), interfaceDir);
+
+        const repoDir = getInterfaceRepoDir(interfaceId);
+        console.log(chalk.dim('  Repo dir:'), repoDir);
+
+        if (fs.existsSync(repoDir)) {
+          console.log(chalk.yellow('  ⚠ Project directory already exists'));
+        } else {
+          fs.mkdirSync(repoDir, { recursive: true });
+          console.log(chalk.dim('  Created directory'));
+
+          const templatesDir = path.join(__dirname, '../../templates');
+          console.log(chalk.dim('  Templates from:'), templatesDir);
+
+          if (!fs.existsSync(templatesDir)) {
+            throw new Error(`Templates directory not found at ${templatesDir}`);
+          }
+
+          writeBoilerplateFiles(repoDir);
+
+          // List what was copied
+          const copiedFiles = fs.readdirSync(repoDir);
+          console.log(chalk.dim('  Copied files:'), copiedFiles.join(', '));
+          console.log(chalk.green('  ✓ Template files copied successfully'));
+        }
+      } catch (copyError) {
+        console.log(chalk.red('  ✗ Failed to copy templates:'), copyError.message);
+        throw copyError;
+      }
+      console.log(chalk.dim('─'.repeat(50)));
+
+      // STEP 4: Install dependencies
+      console.log(chalk.blue('[STEP 4/6]'), 'Installing npm dependencies...');
+      const repoDir = getInterfaceRepoDir(interfaceId);
+      console.log(chalk.dim('  Running: npm install --prefer-offline --no-audit --no-fund'));
+      try {
+        const npmStart = Date.now();
+        await runNpmInstall(repoDir);
+        const npmDuration = ((Date.now() - npmStart) / 1000).toFixed(1);
+        console.log(chalk.green(`  ✓ Dependencies installed (${npmDuration}s)`));
+      } catch (npmError) {
+        console.log(chalk.yellow(`  ⚠ npm install failed: ${npmError.message}`));
+        console.log(chalk.dim('  Dependencies will be installed when you start the dev server'));
+      }
+      console.log(chalk.dim('─'.repeat(50)));
+
+      // STEP 5: Initialize git repository
+      console.log(chalk.blue('[STEP 5/6]'), 'Initializing git repository...');
+      try {
+        // Check if .gitignore exists
+        const gitignorePath = path.join(repoDir, '.gitignore');
+        if (fs.existsSync(gitignorePath)) {
+          const gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
+          const hasNodeModules = gitignoreContent.includes('node_modules');
+          console.log(chalk.dim('  .gitignore exists:'), hasNodeModules ? 'includes node_modules' : 'WARNING: missing node_modules!');
+        } else {
+          console.log(chalk.yellow('  ⚠ No .gitignore found'));
+        }
+
+        // Initialize git repo
+        await runGitCommand(['init'], repoDir);
+        console.log(chalk.green('  ✓ git init completed'));
+
+        // Add remote origin
+        if (githubToken) {
+          const targetUrl = githubRepoUrl.replace('https://github.com/', `https://${githubToken}@github.com/`) + '.git';
+          await runGitCommand(['remote', 'add', 'origin', targetUrl], repoDir);
+          console.log(chalk.green('  ✓ Remote origin added'));
+          console.log(chalk.dim('  Remote URL:'), githubRepoUrl + '.git');
+        } else {
+          console.log(chalk.yellow('  ⚠ No GitHub token - remote not added'));
+        }
+
+        // Set main branch
+        await runGitCommand(['branch', '-M', 'main'], repoDir);
+        console.log(chalk.green('  ✓ Branch set to main'));
+
+        // Initial commit (but don't push yet - that happens on first deploy)
+        await runGitCommand(['add', '.'], repoDir);
+        await runGitCommand(['commit', '-m', 'Initial commit from Lux Studio'], repoDir);
+        console.log(chalk.green('  ✓ Initial commit created'));
+        console.log(chalk.dim('  Note: Push to GitHub will happen on first deploy'));
+      } catch (gitError) {
+        console.log(chalk.yellow(`  ⚠ Git setup failed: ${gitError.message}`));
+      }
+      console.log(chalk.dim('─'.repeat(50)));
+
+      // STEP 6: Save metadata
+      console.log(chalk.blue('[STEP 6/6]'), 'Saving interface metadata...');
+      try {
+        saveInterfaceMetadata(interfaceId, {
+          id: interfaceId,
+          slug,  // Keep slug for display/reference
+          name,
+          description,
+          status: 'draft',  // New interfaces are drafts until first deploy
+          githubUrl: githubRepoUrl,
+          vercelProjectId: vercelProjectId || null,
+          vercelProjectUrl: vercelProjectUrl || null,
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+        });
+        console.log(chalk.green('  ✓ Metadata saved'));
+        console.log(chalk.dim('  ID:'), interfaceId);
+        console.log(chalk.dim('  Slug:'), slug);
+        if (vercelProjectId) {
+          console.log(chalk.dim('  Vercel:'), vercelProjectId);
+        }
+      } catch (metadataError) {
+        console.log(chalk.red('  ✗ Failed to save metadata:'), metadataError.message);
+      }
+      console.log(chalk.dim('─'.repeat(50)));
+
+      console.log(chalk.green('\n✅ Interface created successfully!\n'));
+      console.log(chalk.dim('  Created:'));
+      console.log(chalk.dim('    • Registered in system.interfaces'));
+      console.log(chalk.dim('    • GitHub repository created'));
+      if (vercelProjectId) {
+        console.log(chalk.dim('    • Vercel project created (linked to GitHub)'));
+      }
+      console.log(chalk.dim('    • Project files copied from templates'));
+      console.log(chalk.dim('    • Dependencies installed'));
+      console.log(chalk.dim('    • Git repository initialized'));
+      console.log(chalk.dim('    • Metadata saved locally'));
+
+      console.log(chalk.cyan('\n  Next steps:'));
+      console.log(chalk.dim('    • Start the dev server'));
+      console.log(chalk.dim('    • Edit your code'));
+      console.log(chalk.dim('    • Run'), chalk.white('lux i deploy'), chalk.dim('to push to GitHub (auto-deploys to Vercel)\n'));
+    } else {
+      console.log(chalk.yellow('\n⚠ No GitHub URL returned - skipping local setup'));
+      console.log(chalk.dim('\n  Created:'));
+      console.log(chalk.dim('    • Registered in system.interfaces'));
+      console.log(chalk.cyan('\n  Next steps:'));
+      console.log(chalk.dim('    • Run'), chalk.white('lux i deploy'), chalk.dim('when ready\n'));
+    }
+
+    process.exit(0);
+  } catch (error) {
+    console.log(chalk.red('\n❌ Failed to initialize interface'));
+
+    // Detailed error logging
+    if (error.response) {
+      // Server responded with an error status
+      console.error(chalk.red('\n❌ API Error:'));
+      console.error(chalk.dim('  Status:'), error.response.status);
+      console.error(chalk.dim('  Message:'), error.response.data?.error || error.response.data?.message || 'Unknown error');
+      if (error.response.data?.details) {
+        console.error(chalk.dim('  Details:'), error.response.data.details);
+      }
+      if (error.response.data && typeof error.response.data === 'object') {
+        console.error(chalk.dim('  Full response:'), JSON.stringify(error.response.data, null, 2));
+      }
+    } else if (error.request) {
+      // Request was made but no response received
+      console.error(chalk.red('\n❌ Network Error:'));
+      console.error(chalk.dim('  No response received from server'));
+      console.error(chalk.dim('  URL:'), error.config?.url);
+    } else {
+      // Something else went wrong
+      console.error(chalk.red('\n❌ Error:'), error.message);
+    }
+
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  initInterface,
+  initAndPushToGitHub,
+};

package/commands/interface/path.js

@@ -0,0 +1,74 @@
+const axios = require('axios');
+const chalk = require('chalk');
+const fs = require('fs');
+const {
+  getStudioApiUrl,
+  getAuthHeaders,
+  isAuthenticated,
+  getInterfaceRepoDir,
+} = require('../../lib/config');
+
+/**
+ * Get the local repo path for an interface by ID or name
+ */
+async function getInterfacePath(nameOrId) {
+  if (!nameOrId) {
+    console.log(chalk.red('Error: Interface name or ID is required'));
+    console.log(chalk.dim('Usage: lux app path <name-or-id>'));
+    process.exit(1);
+  }
+
+  // First check if it's directly an ID (looks like a UUID or hex string)
+  const isLikelyId = /^[a-f0-9-]{20,}$/i.test(nameOrId);
+
+  if (isLikelyId) {
+    // Try to use it directly as an ID
+    const repoDir = getInterfaceRepoDir(nameOrId);
+    if (repoDir && fs.existsSync(repoDir)) {
+      console.log(repoDir);
+      return;
+    }
+  }
+
+  // Fetch interfaces from API to find by name or ID
+  if (!isAuthenticated()) {
+    console.log(chalk.red('Not authenticated. Run lux login first.'));
+    process.exit(1);
+  }
+
+  try {
+    const response = await axios.get(`${getStudioApiUrl()}/api/interfaces`, {
+      headers: getAuthHeaders(),
+    });
+
+    const interfaces = response.data.interfaces || [];
+
+    // Find by ID or name (case-insensitive)
+    const match = interfaces.find(i =>
+      i.id === nameOrId ||
+      i.name.toLowerCase() === nameOrId.toLowerCase()
+    );
+
+    if (!match) {
+      console.log(chalk.red(`Interface not found: ${nameOrId}`));
+      console.log(chalk.dim('Run "lux app list" to see available interfaces'));
+      process.exit(1);
+    }
+
+    const repoDir = getInterfaceRepoDir(match.id);
+    if (repoDir && fs.existsSync(repoDir)) {
+      console.log(repoDir);
+    } else {
+      console.log(chalk.red(`Repo directory not found for ${match.name}`));
+      console.log(chalk.dim(`Expected: ${repoDir || 'unknown'}`));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.log(chalk.red('Failed to fetch interfaces:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  getInterfacePath,
+};