luxlabs 1.0.0

package/commands/project.js

@@ -0,0 +1,704 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const axios = require('axios');
+const ora = require('ora');
+const chalk = require('chalk');
+const {
+  getApiUrl,
+  getAuthHeaders,
+  isAuthenticated,
+  getOrgId,
+  getProjectId,
+  LUX_STUDIO_DIR,
+} = require('../lib/config');
+
+/**
+ * Get the project directory path
+ * ~/.lux-studio/{orgId}/projects/{projectId}/
+ */
+function getProjectDir(orgId, projectId) {
+  return path.join(LUX_STUDIO_DIR, orgId, 'projects', projectId);
+}
+
+/**
+ * Create .gitignore for the project
+ */
+function createGitignore(projectDir) {
+  const gitignorePath = path.join(projectDir, '.gitignore');
+  const gitignoreContent = `# Dependencies
+**/node_modules/
+
+# Build outputs
+**/.next/
+**/.vercel/
+**/dist/
+**/build/
+**/.turbo/
+
+# Local KV cache (synced from cloud)
+data/kv/
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+
+# Environment files (secrets)
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+`;
+
+  fs.writeFileSync(gitignorePath, gitignoreContent);
+}
+
+/**
+ * Initialize git in project directory if needed
+ */
+function initGitIfNeeded(projectDir) {
+  const gitDir = path.join(projectDir, '.git');
+
+  if (!fs.existsSync(gitDir)) {
+    execSync('git init', { cwd: projectDir, stdio: 'pipe' });
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Deploy project to GitHub
+ * Force pushes the entire project state to the remote repository
+ */
+async function deployProject(projectId) {
+  // Check authentication
+  if (!isAuthenticated()) {
+    console.log(
+      chalk.red('Not authenticated. Run'),
+      chalk.white('lux login'),
+      chalk.red('first.')
+    );
+    process.exit(1);
+  }
+
+  const orgId = getOrgId();
+  if (!orgId) {
+    console.log(chalk.red('No organization found. Please login first.'));
+    process.exit(1);
+  }
+
+  // Use provided projectId or get current project
+  const targetProjectId = projectId || getProjectId();
+  const projectDir = getProjectDir(orgId, targetProjectId);
+
+  // Check project exists
+  if (!fs.existsSync(projectDir)) {
+    console.log(chalk.red(`Project directory not found: ${projectDir}`));
+    process.exit(1);
+  }
+
+  const repoName = `${orgId}_${targetProjectId}`;
+  const apiUrl = getApiUrl();
+
+  console.log(chalk.dim(`\nProject: ${targetProjectId}`));
+  console.log(chalk.dim(`Directory: ${projectDir}`));
+  console.log(chalk.dim(`Repository: LuxUserProjects/${repoName}\n`));
+
+  // Step 0: Build check - verify all interfaces build successfully (if any exist)
+  const interfacesDir = path.join(projectDir, 'interfaces');
+  let interfaceIds = [];
+
+  if (fs.existsSync(interfacesDir)) {
+    interfaceIds = fs.readdirSync(interfacesDir).filter(f => {
+      const stat = fs.statSync(path.join(interfacesDir, f));
+      return stat.isDirectory();
+    });
+
+    if (interfaceIds.length > 0) {
+      console.log(chalk.dim(`Found ${interfaceIds.length} interface(s) to build\n`));
+
+      for (const interfaceId of interfaceIds) {
+        const repoDir = path.join(interfacesDir, interfaceId, 'repo');
+        const packageJsonPath = path.join(repoDir, 'package.json');
+
+        if (fs.existsSync(packageJsonPath)) {
+          const buildSpinner = ora(`Building interface ${interfaceId.substring(0, 8)}...`).start();
+
+          try {
+            // Install dependencies if node_modules doesn't exist
+            const nodeModulesPath = path.join(repoDir, 'node_modules');
+            if (!fs.existsSync(nodeModulesPath)) {
+              buildSpinner.text = `Installing dependencies for ${interfaceId.substring(0, 8)}...`;
+              execSync('npm install', { cwd: repoDir, stdio: 'pipe', timeout: 300000 });
+            }
+
+            // Run build
+            buildSpinner.text = `Building interface ${interfaceId.substring(0, 8)}...`;
+            execSync('npm run build', { cwd: repoDir, stdio: 'pipe', timeout: 300000 });
+            buildSpinner.succeed(`Interface ${interfaceId.substring(0, 8)} built successfully`);
+          } catch (error) {
+            buildSpinner.fail(`Interface ${interfaceId.substring(0, 8)} build failed`);
+
+            console.log(chalk.red('\n═══════════════════════════════════════════════════════════════'));
+            console.log(chalk.red('                    BUILD FAILED'));
+            console.log(chalk.red('═══════════════════════════════════════════════════════════════\n'));
+
+            // Try to extract useful error info
+            if (error.stdout) {
+              console.log(chalk.dim('--- Build Output ---'));
+              console.log(chalk.dim(error.stdout.toString().slice(-3000)));
+            }
+            if (error.stderr) {
+              console.log(chalk.dim('\n--- Error Output ---'));
+              console.log(chalk.dim(error.stderr.toString().slice(-3000)));
+            }
+
+            console.log(chalk.dim('\n───────────────────────────────────────────────────────────────'));
+            console.log(chalk.cyan('\n💡 To fix this issue, please copy the build error above and'));
+            console.log(chalk.cyan('   share it with your coding agent (Claude) for assistance.\n'));
+            console.log(chalk.dim('   Interface directory:'));
+            console.log(chalk.dim(`   ${repoDir}\n`));
+            console.log(chalk.dim('───────────────────────────────────────────────────────────────\n'));
+
+            process.exit(1);
+          }
+        }
+      }
+    } else {
+      console.log(chalk.dim('No interfaces found. Skipping build step.\n'));
+    }
+  } else {
+    console.log(chalk.dim('No interfaces directory. Skipping build step.\n'));
+  }
+
+  // Step 1: Get deploy credentials (GitHub token, and Vercel projects if interfaces exist)
+  const tokenSpinner = ora('Getting deploy credentials...').start();
+
+  let repoUrl, token, interfaces;
+  try {
+    const { data } = await axios.post(
+      `${apiUrl}/api/projects/${targetProjectId}/deploy/init`,
+      { orgId, interfaceIds },
+      { headers: getAuthHeaders() }
+    );
+
+    repoUrl = data.repoUrl;
+    token = data.token;
+    interfaces = data.interfaces || [];
+
+    if (interfaces.length > 0) {
+      tokenSpinner.succeed(`Got deploy credentials for ${interfaces.length} interface(s)`);
+    } else {
+      tokenSpinner.succeed('Got deploy credentials (no interfaces to deploy to Vercel)');
+    }
+  } catch (error) {
+    tokenSpinner.fail('Failed to get deploy credentials');
+    console.error(
+      chalk.red('\nError:'),
+      error.response?.data?.error || error.message
+    );
+
+    if (error.response?.status === 401) {
+      console.log(
+        chalk.yellow('\nYour session may have expired. Try running:'),
+        chalk.white('lux login')
+      );
+    }
+
+    process.exit(1);
+  }
+
+  // Step 2: Initialize git if needed
+  const gitSpinner = ora('Preparing git repository...').start();
+
+  try {
+    const wasInitialized = initGitIfNeeded(projectDir);
+    if (wasInitialized) {
+      gitSpinner.text = 'Initialized git repository';
+    }
+
+    // Create/update .gitignore
+    createGitignore(projectDir);
+
+    // Always configure git user (required for commits)
+    execSync('git config user.email "deploy@uselux.ai"', { cwd: projectDir, stdio: 'pipe' });
+    execSync('git config user.name "Lux Deploy"', { cwd: projectDir, stdio: 'pipe' });
+
+    gitSpinner.succeed('Git repository ready');
+  } catch (error) {
+    gitSpinner.fail('Failed to prepare git repository');
+    console.error(chalk.red('\nError:'), error.message);
+    process.exit(1);
+  }
+
+  // Step 3: Stage all files
+  const stageSpinner = ora('Staging files...').start();
+
+  try {
+    execSync('git add -A', { cwd: projectDir, stdio: 'pipe' });
+    stageSpinner.succeed('Files staged');
+  } catch (error) {
+    stageSpinner.fail('Failed to stage files');
+    console.error(chalk.red('\nError:'), error.message);
+    process.exit(1);
+  }
+
+  // Step 4: Commit
+  const commitSpinner = ora('Creating commit...').start();
+
+  try {
+    const timestamp = new Date().toISOString();
+    const commitMessage = `Deploy ${timestamp}`;
+
+    // Check if we have any commits at all
+    let hasCommits = false;
+    try {
+      execSync('git rev-parse HEAD', { cwd: projectDir, stdio: 'pipe' });
+      hasCommits = true;
+    } catch {
+      hasCommits = false;
+    }
+
+    // Check if there are staged changes
+    const stagedDiff = execSync('git diff --cached --name-only', { cwd: projectDir, encoding: 'utf-8' });
+
+    if (stagedDiff.trim() === '' && hasCommits) {
+      // No staged changes and already has commits
+      commitSpinner.succeed('No changes to commit');
+    } else if (!hasCommits) {
+      // First commit - use --allow-empty if needed
+      try {
+        execSync(`git commit -m "${commitMessage}"`, { cwd: projectDir, stdio: 'pipe' });
+        commitSpinner.succeed('Created initial commit');
+      } catch {
+        execSync(`git commit --allow-empty -m "${commitMessage}"`, { cwd: projectDir, stdio: 'pipe' });
+        commitSpinner.succeed('Created initial commit');
+      }
+    } else {
+      // Has staged changes
+      execSync(`git commit -m "${commitMessage}"`, { cwd: projectDir, stdio: 'pipe' });
+      commitSpinner.succeed('Commit created');
+    }
+  } catch (error) {
+    // If commit fails because nothing to commit, that's OK
+    const errorStr = error.message + (error.stderr || '');
+    if (errorStr.includes('nothing to commit') || errorStr.includes('nothing added to commit')) {
+      commitSpinner.succeed('No changes to commit');
+    } else {
+      commitSpinner.fail('Failed to create commit');
+      console.error(chalk.red('\nError:'), error.message);
+      if (error.stderr) console.error(chalk.dim(error.stderr));
+      process.exit(1);
+    }
+  }
+
+  // Step 5: Push to GitHub (force push)
+  const pushSpinner = ora('Pushing to GitHub...').start();
+
+  try {
+    // Construct authenticated URL
+    const authUrl = repoUrl.replace('https://github.com/', `https://x-access-token:${token}@github.com/`);
+
+    // Set remote (or update if exists)
+    try {
+      execSync(`git remote add origin ${authUrl}`, { cwd: projectDir, stdio: 'pipe' });
+    } catch {
+      // Remote might already exist, update it
+      execSync(`git remote set-url origin ${authUrl}`, { cwd: projectDir, stdio: 'pipe' });
+    }
+
+    // Always ensure we're on main branch before pushing
+    execSync('git branch -M main', { cwd: projectDir, stdio: 'pipe' });
+
+    // Force push to main
+    execSync('git push -f origin main', { cwd: projectDir, stdio: 'pipe', timeout: 120000 });
+
+    // Clear the token from remote URL after push (security)
+    execSync(`git remote set-url origin ${repoUrl}`, { cwd: projectDir, stdio: 'pipe' });
+
+    pushSpinner.succeed('Pushed to GitHub');
+  } catch (error) {
+    pushSpinner.fail('Failed to push to GitHub');
+    console.error(chalk.red('\nError:'), error.message);
+
+    // Clear token from URL even on failure
+    try {
+      execSync(`git remote set-url origin ${repoUrl}`, { cwd: projectDir, stdio: 'pipe' });
+    } catch {
+      // Ignore
+    }
+
+    process.exit(1);
+  }
+
+  // Track overall deployment errors
+  let interfaceHasErrors = false;
+
+  // Step 6: Trigger Vercel deployment for each interface (if any)
+  if (interfaces.length > 0) {
+    console.log(chalk.dim(`\nDeploying ${interfaces.length} interface(s) to Vercel...\n`));
+
+    const deploymentResults = [];
+
+    for (const iface of interfaces) {
+      const vercelSpinner = ora(`Deploying interface ${iface.interfaceId.substring(0, 8)}...`).start();
+
+      try {
+        const { data: deployData } = await axios.post(
+          `${apiUrl}/api/projects/${targetProjectId}/deploy/trigger`,
+          {
+            vercelProjectId: iface.vercelProjectId,
+            vercelProjectName: iface.vercelProjectName,
+            repoName: repoName.toLowerCase(),
+            interfaceId: iface.interfaceId
+          },
+          { headers: getAuthHeaders() }
+        );
+
+        vercelSpinner.succeed(`Interface ${iface.interfaceId.substring(0, 8)} deployment triggered`);
+
+        // Sync local custom domains to Vercel after successful deployment
+        const interfaceMetadataPath = path.join(interfacesDir, iface.interfaceId, 'metadata.json');
+        if (fs.existsSync(interfaceMetadataPath)) {
+          try {
+            const metadata = JSON.parse(fs.readFileSync(interfaceMetadataPath, 'utf-8'));
+            const localDomains = metadata.customDomains || [];
+            const pendingDomains = localDomains.filter(d => !d.synced);
+
+            if (pendingDomains.length > 0) {
+              const domainSpinner = ora(`Syncing ${pendingDomains.length} custom domain(s)...`).start();
+
+              for (const domainInfo of pendingDomains) {
+                try {
+                  // Add domain to Vercel via backend API
+                  await axios.post(
+                    `${apiUrl}/api/interfaces/${iface.interfaceId}/domains`,
+                    { domain: domainInfo.domain },
+                    { headers: getAuthHeaders() }
+                  );
+
+                  // Mark as synced in local metadata
+                  domainInfo.synced = true;
+                  domainInfo.syncedAt = new Date().toISOString();
+                } catch (domainError) {
+                  console.log(chalk.dim(`\n  Warning: Failed to add domain ${domainInfo.domain}: ${domainError.response?.data?.error || domainError.message}`));
+                }
+              }
+
+              // Save updated metadata
+              fs.writeFileSync(interfaceMetadataPath, JSON.stringify(metadata, null, 2));
+
+              const syncedCount = pendingDomains.filter(d => d.synced).length;
+              if (syncedCount === pendingDomains.length) {
+                domainSpinner.succeed(`${syncedCount} custom domain(s) synced`);
+              } else {
+                domainSpinner.warn(`${syncedCount}/${pendingDomains.length} custom domain(s) synced`);
+              }
+            }
+          } catch (metadataError) {
+            // Ignore metadata errors - domain sync is optional
+          }
+        }
+
+        deploymentResults.push({
+          interfaceId: iface.interfaceId,
+          name: iface.interfaceName || iface.interfaceId.substring(0, 8),
+          success: true,
+          url: deployData.deployment_url,
+          subdomainUrl: iface.subdomainUrl,
+          deploymentId: deployData.deployment_id
+        });
+      } catch (error) {
+        interfaceHasErrors = true;
+        vercelSpinner.fail(`Interface ${iface.interfaceId.substring(0, 8)} deployment failed`);
+        const errorData = error.response?.data;
+        deploymentResults.push({
+          interfaceId: iface.interfaceId,
+          name: iface.interfaceName || iface.interfaceId.substring(0, 8),
+          success: false,
+          error: errorData?.error || error.message
+        });
+      }
+    }
+
+    // Summary
+    console.log('');
+    if (interfaceHasErrors) {
+      console.log(chalk.yellow('═══════════════════════════════════════════════════════════════'));
+      console.log(chalk.yellow('              DEPLOYMENT COMPLETED WITH ERRORS'));
+      console.log(chalk.yellow('═══════════════════════════════════════════════════════════════\n'));
+    } else {
+      console.log(chalk.green('═══════════════════════════════════════════════════════════════'));
+      console.log(chalk.green('              ALL DEPLOYMENTS SUCCESSFUL'));
+      console.log(chalk.green('═══════════════════════════════════════════════════════════════\n'));
+    }
+
+    console.log(chalk.dim(`GitHub: ${repoUrl}\n`));
+
+    for (const result of deploymentResults) {
+      if (result.success) {
+        console.log(chalk.green(`✓ ${result.interfaceId.substring(0, 8)}`));
+        console.log(chalk.dim(`  URL: ${result.url}`));
+        console.log(chalk.dim(`  Deployment ID: ${result.deploymentId}`));
+      } else {
+        console.log(chalk.red(`✗ ${result.interfaceId.substring(0, 8)}`));
+        console.log(chalk.dim(`  Error: ${result.error}`));
+      }
+      console.log('');
+    }
+
+    if (interfaceHasErrors) {
+      console.log(chalk.dim('───────────────────────────────────────────────────────────────'));
+      console.log(chalk.cyan('\n💡 To debug failed deployments, check the Vercel dashboard:'));
+      console.log(chalk.dim('   https://vercel.com/dashboard\n'));
+      console.log(chalk.dim('───────────────────────────────────────────────────────────────\n'));
+    }
+  } else {
+    // No interfaces - just show GitHub success
+    console.log('');
+    console.log(chalk.green('═══════════════════════════════════════════════════════════════'));
+    console.log(chalk.green('              PROJECT PUSHED TO GITHUB'));
+    console.log(chalk.green('═══════════════════════════════════════════════════════════════\n'));
+    console.log(chalk.dim(`GitHub: ${repoUrl}\n`));
+    console.log(chalk.dim('No interfaces to deploy to Vercel.\n'));
+  }
+
+  // Step 7: Deploy flows (if any exist)
+  const flowsDir = path.join(projectDir, 'flows');
+  if (fs.existsSync(flowsDir)) {
+    const flowFiles = fs.readdirSync(flowsDir).filter(f => f.endsWith('.json'));
+
+    if (flowFiles.length > 0) {
+      console.log(chalk.dim(`\nDeploying ${flowFiles.length} flow(s)...\n`));
+
+      const flowResults = [];
+      let flowHasErrors = false;
+
+      for (const flowFile of flowFiles) {
+        const flowId = flowFile.replace('.json', '');
+        const flowSpinner = ora(`Deploying flow ${flowId.substring(0, 8)}...`).start();
+
+        try {
+          // Read flow data
+          const flowPath = path.join(flowsDir, flowFile);
+          const flowData = JSON.parse(fs.readFileSync(flowPath, 'utf-8'));
+
+          // 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`,
+            {
+              // Wrap flow data in config object as expected by /publish
+              config: {
+                nodes: flowData.nodes,
+                edges: flowData.edges,
+                variables: flowData.variables || {},
+                metadata: {
+                  name: flowData.name,
+                  description: flowData.description,
+                  ...flowData.metadata,
+                },
+              },
+            },
+            { headers: getAuthHeaders() }
+          );
+
+          flowSpinner.succeed(`Flow ${flowId.substring(0, 8)} deployed`);
+          flowResults.push({
+            flowId,
+            name: flowData.name,
+            success: true,
+            webhookUrl: deployData.workflow?.webhook_token ? `${apiUrl}/api/webhooks/${deployData.workflow.webhook_token}` : null,
+          });
+
+          // Update local flow with webhook URL
+          flowData.deployedAt = new Date().toISOString();
+          const webhookToken = deployData.workflow?.webhook_token;
+          flowData.webhookUrl = webhookToken ? `${apiUrl}/api/webhooks/${webhookToken}` : null;
+          fs.writeFileSync(flowPath, JSON.stringify(flowData, null, 2));
+        } catch (error) {
+          flowHasErrors = true;
+          flowSpinner.fail(`Flow ${flowId.substring(0, 8)} deployment failed`);
+          const errorData = error.response?.data;
+          flowResults.push({
+            flowId,
+            success: false,
+            error: errorData?.error || error.message,
+          });
+        }
+      }
+
+      // Flow deployment summary
+      console.log('');
+      if (flowHasErrors) {
+        console.log(chalk.yellow('Some flow deployments failed:\n'));
+      } else {
+        console.log(chalk.green('All flows deployed successfully:\n'));
+      }
+
+      for (const result of flowResults) {
+        if (result.success) {
+          console.log(chalk.green(`✓ ${result.name || result.flowId.substring(0, 8)}`));
+          if (result.webhookUrl) {
+            console.log(chalk.dim(`  Webhook: ${result.webhookUrl}`));
+          }
+        } else {
+          console.log(chalk.red(`✗ ${result.flowId.substring(0, 8)}`));
+          console.log(chalk.dim(`  Error: ${result.error}`));
+        }
+      }
+      console.log('');
+
+      // Exit with error if any flows failed
+      if (flowHasErrors) {
+        process.exit(1);
+      }
+    }
+  }
+
+  // Output JSON summary for programmatic parsing (Lux Studio)
+  // Format: __LUX_DEPLOY_RESULT__{json}__END_LUX_DEPLOY_RESULT__
+  if (interfaces.length > 0) {
+    const deploymentSummary = {
+      success: !interfaceHasErrors,
+      interfaces: deploymentResults.map(r => ({
+        id: r.interfaceId,
+        name: r.name,
+        success: r.success,
+        subdomainUrl: r.subdomainUrl,
+        deploymentUrl: r.url,
+        error: r.error
+      }))
+    };
+    console.log(`__LUX_DEPLOY_RESULT__${JSON.stringify(deploymentSummary)}__END_LUX_DEPLOY_RESULT__`);
+  }
+
+  // Exit with error if any interface deployments failed (and no flows were deployed)
+  if (interfaceHasErrors) {
+    process.exit(1);
+  }
+}
+
+/**
+ * Show project status
+ */
+async function projectStatus(projectId) {
+  if (!isAuthenticated()) {
+    console.log(
+      chalk.red('Not authenticated. Run'),
+      chalk.white('lux login'),
+      chalk.red('first.')
+    );
+    process.exit(1);
+  }
+
+  const orgId = getOrgId();
+  if (!orgId) {
+    console.log(chalk.red('No organization found. Please login first.'));
+    process.exit(1);
+  }
+
+  const targetProjectId = projectId || getProjectId();
+  const projectDir = getProjectDir(orgId, targetProjectId);
+  const repoName = `${orgId}_${targetProjectId}`;
+
+  console.log(chalk.bold('\nProject Status\n'));
+  console.log(`  Project ID:  ${chalk.cyan(targetProjectId)}`);
+  console.log(`  Directory:   ${chalk.dim(projectDir)}`);
+  console.log(`  Repository:  ${chalk.dim(`LuxOrg/${repoName}`)}`);
+
+  // Check if project exists locally
+  if (!fs.existsSync(projectDir)) {
+    console.log(chalk.yellow('\n  Local project directory not found.'));
+    return;
+  }
+
+  // Check git status
+  const gitDir = path.join(projectDir, '.git');
+  if (fs.existsSync(gitDir)) {
+    try {
+      const status = execSync('git status --porcelain', { cwd: projectDir, encoding: 'utf-8' });
+      const lines = status.trim().split('\n').filter(l => l.trim());
+
+      if (lines.length === 0) {
+        console.log(chalk.green('\n  No uncommitted changes.'));
+      } else {
+        console.log(chalk.yellow(`\n  ${lines.length} uncommitted changes:`));
+        lines.slice(0, 10).forEach(line => {
+          console.log(chalk.dim(`    ${line}`));
+        });
+        if (lines.length > 10) {
+          console.log(chalk.dim(`    ... and ${lines.length - 10} more`));
+        }
+      }
+
+      // Check if remote exists
+      try {
+        const remote = execSync('git remote get-url origin', { cwd: projectDir, encoding: 'utf-8' }).trim();
+        console.log(chalk.dim(`\n  Remote: ${remote}`));
+      } catch {
+        console.log(chalk.yellow('\n  No remote configured. Run `lux project deploy` to push to GitHub.'));
+      }
+    } catch (error) {
+      console.log(chalk.dim('\n  Unable to get git status.'));
+    }
+  } else {
+    console.log(chalk.yellow('\n  Git not initialized. Run `lux project deploy` to initialize and push.'));
+  }
+
+  console.log('');
+}
+
+/**
+ * Handle project commands
+ */
+async function handleProject(args) {
+  const subcommand = args[0];
+  const subArgs = args.slice(1);
+
+  switch (subcommand) {
+    case 'deploy':
+    case 'push': {
+      const projectId = subArgs[0]; // Optional: specific project ID
+      await deployProject(projectId);
+      break;
+    }
+
+    case 'status': {
+      const projectId = subArgs[0];
+      await projectStatus(projectId);
+      break;
+    }
+
+    case 'help':
+    default:
+      console.log(chalk.bold('\nLux Project Commands\n'));
+      console.log('Usage: lux project <command> [options]\n');
+      console.log('Commands:');
+      console.log('  deploy [projectId]    Push project to GitHub (force push entire state)');
+      console.log('  push [projectId]      Alias for deploy');
+      console.log('  status [projectId]    Show project status');
+      console.log('');
+      console.log('Examples:');
+      console.log('  lux project deploy                  Deploy current project');
+      console.log('  lux project deploy my-project-id    Deploy specific project');
+      console.log('  lux project status                  Show current project status');
+      console.log('');
+      break;
+  }
+}
+
+module.exports = {
+  handleProject,
+  deployProject,
+};