@aifabrix/builder 2.1.7 → 2.2.0

package/lib/build.js

@@ -19,10 +19,12 @@ const { promisify } = require('util');
 const chalk = require('chalk');
 const yaml = require('js-yaml');
 const secrets = require('./secrets');
+const config = require('./config');
 const logger = require('./utils/logger');
 const validator = require('./validator');
 const dockerfileUtils = require('./utils/dockerfile-utils');
 const dockerBuild = require('./utils/docker-build');
+const buildCopy = require('./utils/build-copy');
 
 const execAsync = promisify(exec);
 
@@ -127,7 +129,7 @@ function detectLanguage(appPath) {
  * const dockerfilePath = await generateDockerfile('myapp', 'typescript', config);
  * // Returns: '~/.aifabrix/myapp/Dockerfile.typescript'
  */
-async function generateDockerfile(appNameOrPath, language, config, buildConfig = {}) {
+async function generateDockerfile(appNameOrPath, language, config, buildConfig = {}, devDir = null) {
   let appName;
   if (appNameOrPath.includes(path.sep) || appNameOrPath.includes('/') || appNameOrPath.includes('\\')) {
     appName = path.basename(appNameOrPath);
@@ -151,12 +153,19 @@ async function generateDockerfile(appNameOrPath, language, config, buildConfig =
 
   const dockerfileContent = dockerfileUtils.renderDockerfile(template, templateVars, language, isAppFlag, appSourcePath);
 
-  const aifabrixDir = path.join(os.homedir(), '.aifabrix', appName);
-  if (!fsSync.existsSync(aifabrixDir)) {
-    await fs.mkdir(aifabrixDir, { recursive: true });
+  // Use dev directory if provided, otherwise use default aifabrix directory
+  let targetDir;
+  if (devDir) {
+    targetDir = devDir;
+  } else {
+    targetDir = path.join(os.homedir(), '.aifabrix', appName);
+  }
+
+  if (!fsSync.existsSync(targetDir)) {
+    await fs.mkdir(targetDir, { recursive: true });
   }
 
-  const dockerfilePath = path.join(aifabrixDir, `Dockerfile.${language}`);
+  const dockerfilePath = path.join(targetDir, 'Dockerfile');
   await fs.writeFile(dockerfilePath, dockerfileContent, 'utf8');
 
   return dockerfilePath;
@@ -175,41 +184,29 @@ async function generateDockerfile(appNameOrPath, language, config, buildConfig =
  * @returns {Promise<string>} Path to Dockerfile
  */
 async function determineDockerfile(appName, options) {
-  const builderPath = path.join(process.cwd(), 'builder', appName);
+  // Use dev directory if provided, otherwise fall back to builder directory
+  const searchPath = options.devDir || path.join(process.cwd(), 'builder', appName);
 
-  const templateDockerfile = dockerfileUtils.checkTemplateDockerfile(builderPath, appName, options.forceTemplate);
+  const templateDockerfile = dockerfileUtils.checkTemplateDockerfile(searchPath, appName, options.forceTemplate);
   if (templateDockerfile) {
-    logger.log(chalk.green(`✓ Using existing Dockerfile: builder/${appName}/Dockerfile`));
+    const relativePath = path.relative(process.cwd(), templateDockerfile);
+    logger.log(chalk.green(`✓ Using existing Dockerfile: ${relativePath}`));
     return templateDockerfile;
   }
 
-  const customDockerfile = dockerfileUtils.checkProjectDockerfile(builderPath, appName, options.buildConfig, options.contextPath, options.forceTemplate);
+  const customDockerfile = dockerfileUtils.checkProjectDockerfile(searchPath, appName, options.buildConfig, options.contextPath, options.forceTemplate);
   if (customDockerfile) {
     logger.log(chalk.green(`✓ Using custom Dockerfile: ${options.buildConfig.dockerfile}`));
     return customDockerfile;
   }
 
-  const dockerfilePath = await generateDockerfile(appName, options.language, options.config, options.buildConfig);
+  // Generate Dockerfile in dev directory if provided
+  const dockerfilePath = await generateDockerfile(appName, options.language, options.config, options.buildConfig, options.devDir);
   const relativePath = path.relative(process.cwd(), dockerfilePath);
   logger.log(chalk.green(`✓ Generated Dockerfile from template: ${relativePath}`));
   return dockerfilePath;
 }
 
-/**
- * Prepares build context path
- * @param {string} appName - Application name
- * @param {string} contextPath - Relative context path
- * @returns {string} Absolute context path
- */
-function prepareBuildContext(appName, contextPath) {
-  // Ensure contextPath is a string
-  const context = typeof contextPath === 'string' ? contextPath : (contextPath || '');
-  return resolveContextPath(
-    path.join(process.cwd(), 'builder', appName),
-    context
-  );
-}
-
 /**
  * Loads and validates configuration for build
  * @async
@@ -309,20 +306,41 @@ async function buildApp(appName, options = {}) {
     logger.log(chalk.blue(`\n🔨 Building application: ${appName}`));
 
     // 1. Load and validate configuration
-    const { config, imageName, buildConfig } = await loadAndValidateConfig(appName);
-
-    // 2. Prepare build context
-    const contextPath = prepareBuildContext(appName, buildConfig.context);
+    const { config: appConfig, imageName, buildConfig } = await loadAndValidateConfig(appName);
+
+    // 2. Get developer ID and copy files to dev-specific directory
+    const developerId = await config.getDeveloperId();
+    const directoryName = developerId === 0 ? 'applications' : `dev-${developerId}`;
+    logger.log(chalk.blue(`Copying files to developer-specific directory (${directoryName})...`));
+    const devDir = await buildCopy.copyBuilderToDevDirectory(appName, developerId);
+    logger.log(chalk.green(`✓ Files copied to: ${devDir}`));
+
+    // 3. Prepare build context (use dev-specific directory)
+    // If buildConfig.context is relative, resolve it relative to devDir
+    // If buildConfig.context is '../..' (apps flag), keep it as is (it's relative to devDir)
+    let contextPath;
+    if (buildConfig.context && buildConfig.context !== '../..') {
+      // Resolve relative context path from dev directory
+      contextPath = path.resolve(devDir, buildConfig.context);
+    } else if (buildConfig.context === '../..') {
+      // For apps flag, context is relative to devDir (which is ~/.aifabrix/<app>-dev-<id>)
+      // So '../..' from devDir goes to ~/.aifabrix, then we need to go to project root
+      // Actually, we need to keep the relative path and let Docker resolve it
+      // But the build context should be the project root, not devDir
+      contextPath = process.cwd();
+    } else {
+      // No context specified, use dev directory
+      contextPath = devDir;
+    }
 
-    // 3. Check if Dockerfile exists in builder/{appName}/ directory
-    const builderPath = path.join(process.cwd(), 'builder', appName);
-    const appDockerfilePath = path.join(builderPath, 'Dockerfile');
+    // 4. Check if Dockerfile exists in dev directory
+    const appDockerfilePath = path.join(devDir, 'Dockerfile');
     const hasExistingDockerfile = fsSync.existsSync(appDockerfilePath) && !options.forceTemplate;
 
-    // 4. Determine language (skip if existing Dockerfile found)
+    // 5. Determine language (skip if existing Dockerfile found)
     let language = options.language || buildConfig.language;
     if (!language && !hasExistingDockerfile) {
-      language = detectLanguage(builderPath);
+      language = detectLanguage(devDir);
     } else if (!language) {
       // Default language if existing Dockerfile is found (won't be used, but needed for API)
       language = 'typescript';
@@ -331,13 +349,15 @@ async function buildApp(appName, options = {}) {
       logger.log(chalk.green(`✓ Detected language: ${language}`));
     }
 
-    // 5. Determine Dockerfile (needs context path to generate in correct location)
+    // 6. Determine Dockerfile (needs context path to generate in correct location)
+    // Use dev directory for Dockerfile generation
     const dockerfilePath = await determineDockerfile(appName, {
       language,
-      config,
+      config: appConfig,
       buildConfig,
       contextPath,
-      forceTemplate: options.forceTemplate
+      forceTemplate: options.forceTemplate,
+      devDir: devDir
     });
 
     // 6. Build Docker image

package/lib/cli.js

@@ -15,6 +15,8 @@ const secrets = require('./secrets');
 const generator = require('./generator');
 const validator = require('./validator');
 const keyGenerator = require('./key-generator');
+const config = require('./config');
+const devConfig = require('./utils/dev-config');
 const chalk = require('chalk');
 const logger = require('./utils/logger');
 const { validateCommand, handleCommandError } = require('./utils/cli-utils');
@@ -28,11 +30,12 @@ function setupCommands(program) {
   // Authentication command
   program.command('login')
     .description('Authenticate with Miso Controller')
-    .option('-u, --url <url>', 'Controller URL', 'http://localhost:3000')
+    .option('-c, --controller <url>', 'Controller URL', 'http://localhost:3000')
     .option('-m, --method <method>', 'Authentication method (device|credentials)')
-    .option('--client-id <id>', 'Client ID (for credentials method)')
-    .option('--client-secret <secret>', 'Client Secret (for credentials method)')
-    .option('-e, --environment <env>', 'Environment key (for device method, e.g., dev, tst, pro)')
+    .option('-a, --app <app>', 'Application name (required for credentials method, reads from secrets.local.yaml)')
+    .option('--client-id <id>', 'Client ID (for credentials method, overrides secrets.local.yaml)')
+    .option('--client-secret <secret>', 'Client Secret (for credentials method, overrides secrets.local.yaml)')
+    .option('-e, --environment <env>', 'Environment key (updates root-level environment in config.yaml, e.g., miso, dev, tst, pro)')
     .action(async(options) => {
       try {
         await handleLogin(options);
@@ -45,9 +48,21 @@ function setupCommands(program) {
   // Infrastructure commands
   program.command('up')
     .description('Start local infrastructure services (Postgres, Redis, pgAdmin, Redis Commander)')
-    .action(async() => {
+    .option('-d, --developer <id>', 'Set developer ID and start infrastructure')
+    .action(async(options) => {
       try {
-        await infra.startInfra();
+        let developerId = null;
+        if (options.developer) {
+          const id = parseInt(options.developer, 10);
+          if (isNaN(id) || id < 0) {
+            throw new Error('Developer ID must be a non-negative number (0 = default infra, > 0 = developer-specific)');
+          }
+          await config.setDeveloperId(id);
+          process.env.AIFABRIX_DEVELOPERID = id.toString();
+          developerId = id;
+          logger.log(chalk.green(`✓ Developer ID set to ${id}`));
+        }
+        await infra.startInfra(developerId);
       } catch (error) {
         handleCommandError(error, 'up');
         process.exit(1);
@@ -138,7 +153,7 @@ function setupCommands(program) {
   program.command('deploy <app>')
     .description('Deploy to Azure via Miso Controller')
     .option('-c, --controller <url>', 'Controller URL')
-    .option('-e, --environment <env>', 'Environment (dev, tst, pro)', 'dev')
+    .option('-e, --environment <env>', 'Environment (miso, dev, tst, pro)', 'dev')
     .option('--client-id <id>', 'Client ID (overrides config)')
     .option('--client-secret <secret>', 'Client Secret (overrides config)')
     .option('--poll', 'Poll for deployment status', true)
@@ -191,7 +206,7 @@ function setupCommands(program) {
     });
 
   program.command('status')
-    .description('Show detailed infrastructure service status')
+    .description('Show detailed infrastructure service status and running applications')
     .action(async() => {
       try {
         const status = await infra.getInfraStatus();
@@ -207,6 +222,22 @@ function setupCommands(program) {
           logger.log(`   URL: ${info.url}`);
           logger.log('');
         });
+
+        // Show running applications
+        const apps = await infra.getAppStatus();
+        if (apps.length > 0) {
+          logger.log('📱 Running Applications\n');
+          apps.forEach((app) => {
+            const normalizedStatus = String(app.status).trim().toLowerCase();
+            const icon = normalizedStatus.includes('running') || normalizedStatus.includes('up') ? '✅' : '❌';
+            logger.log(`${icon} ${app.name}:`);
+            logger.log(`   Container: ${app.container}`);
+            logger.log(`   Port: ${app.port}`);
+            logger.log(`   Status: ${app.status}`);
+            logger.log(`   URL: ${app.url}`);
+            logger.log('');
+          });
+        }
       } catch (error) {
         handleCommandError(error, 'status');
         process.exit(1);
@@ -291,6 +322,57 @@ function setupCommands(program) {
         process.exit(1);
       }
     });
+
+  // Developer configuration commands
+  program.command('dev config')
+    .description('Show or set developer configuration')
+    .option('--set-id <id>', 'Set developer ID')
+    .action(async(cmdName, opts) => {
+      try {
+        // For commands with spaces like 'dev config', Commander.js passes command name as first arg
+        // Options are passed as second arg, or if only one arg, it might be the command name
+        const options = typeof cmdName === 'object' && cmdName !== null ? cmdName : (opts || {});
+        // Commander.js converts --set-id to setId in options object
+        const setIdValue = options.setId || options['set-id'];
+        if (setIdValue) {
+          const id = parseInt(setIdValue, 10);
+          if (isNaN(id) || id < 0) {
+            throw new Error('Developer ID must be a non-negative number (0 = default infra, > 0 = developer-specific)');
+          }
+          await config.setDeveloperId(id);
+          process.env.AIFABRIX_DEVELOPERID = id.toString();
+          logger.log(chalk.green(`✓ Developer ID set to ${id}`));
+          // Use the ID we just set instead of reading from file to avoid race conditions
+          const devId = id;
+          const ports = devConfig.getDevPorts(devId);
+          logger.log('\n🔧 Developer Configuration\n');
+          logger.log(`Developer ID: ${devId}`);
+          logger.log('\nPorts:');
+          logger.log(`  App: ${ports.app}`);
+          logger.log(`  Postgres: ${ports.postgres}`);
+          logger.log(`  Redis: ${ports.redis}`);
+          logger.log(`  pgAdmin: ${ports.pgadmin}`);
+          logger.log(`  Redis Commander: ${ports.redisCommander}`);
+          logger.log('');
+          return;
+        }
+
+        const devId = await config.getDeveloperId();
+        const ports = devConfig.getDevPorts(devId);
+        logger.log('\n🔧 Developer Configuration\n');
+        logger.log(`Developer ID: ${devId}`);
+        logger.log('\nPorts:');
+        logger.log(`  App: ${ports.app}`);
+        logger.log(`  Postgres: ${ports.postgres}`);
+        logger.log(`  Redis: ${ports.redis}`);
+        logger.log(`  pgAdmin: ${ports.pgadmin}`);
+        logger.log(`  Redis Commander: ${ports.redisCommander}`);
+        logger.log('');
+      } catch (error) {
+        handleCommandError(error, 'dev config');
+        process.exit(1);
+      }
+    });
 }
 
 module.exports = {