@aifabrix/builder 2.1.7 → 2.3.0

package/lib/build.js

@@ -19,13 +19,61 @@ 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);
 
+/**
+ * Copies application template files to dev directory
+ * Used when apps directory doesn't exist to ensure build can proceed
+ * @async
+ * @param {string} templatePath - Path to template directory
+ * @param {string} devDir - Target dev directory
+ * @param {string} _language - Language (typescript/python) - currently unused but kept for future use
+ * @throws {Error} If copying fails
+ */
+async function copyTemplateFilesToDevDir(templatePath, devDir, _language) {
+  if (!fsSync.existsSync(templatePath)) {
+    throw new Error(`Template path not found: ${templatePath}`);
+  }
+
+  const entries = await fs.readdir(templatePath);
+
+  // Copy only application files, skip Dockerfile and docker-compose templates
+  const appFiles = entries.filter(entry => {
+    const lowerEntry = entry.toLowerCase();
+    // Include .gitignore, exclude .hbs files and docker-related files
+    if (entry === '.gitignore') {
+      return true;
+    }
+    if (lowerEntry.endsWith('.hbs')) {
+      return false;
+    }
+    if (lowerEntry.startsWith('dockerfile') || lowerEntry.includes('docker-compose')) {
+      return false;
+    }
+    if (entry.startsWith('.') && entry !== '.gitignore') {
+      return false;
+    }
+    return true;
+  });
+
+  for (const entry of appFiles) {
+    const sourcePath = path.join(templatePath, entry);
+    const targetPath = path.join(devDir, entry);
+
+    const entryStats = await fs.stat(sourcePath);
+    if (entryStats.isFile()) {
+      await fs.copyFile(sourcePath, targetPath);
+    }
+  }
+}
+
 /**
  * Loads variables.yaml configuration for an application
  * @param {string} appName - Application name
@@ -89,7 +137,6 @@ function detectLanguage(appPath) {
   const packageJsonPath = path.join(appPath, 'package.json');
   const requirementsPath = path.join(appPath, 'requirements.txt');
   const pyprojectPath = path.join(appPath, 'pyproject.toml');
-  const dockerfilePath = path.join(appPath, 'Dockerfile');
 
   // Check for package.json (TypeScript/Node.js)
   if (fsSync.existsSync(packageJsonPath)) {
@@ -101,11 +148,6 @@ function detectLanguage(appPath) {
     return 'python';
   }
 
-  // Check for custom Dockerfile
-  if (fsSync.existsSync(dockerfilePath)) {
-    throw new Error('Custom Dockerfile found. Use --force-template to regenerate from template.');
-  }
-
   // Default to typescript if no indicators found
   return 'typescript';
 }
@@ -127,7 +169,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 +193,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);
   }
 
-  const dockerfilePath = path.join(aifabrixDir, `Dockerfile.${language}`);
+  if (!fsSync.existsSync(targetDir)) {
+    await fs.mkdir(targetDir, { recursive: true });
+  }
+
+  const dockerfilePath = path.join(targetDir, 'Dockerfile');
   await fs.writeFile(dockerfilePath, dockerfileContent, 'utf8');
 
   return dockerfilePath;
@@ -175,41 +224,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 +346,89 @@ 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);
+    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}`));
+
+    // 2a. Check if application source files exist, if not copy from templates
+    const appsPath = path.join(process.cwd(), 'apps', appName);
+    if (fsSync.existsSync(appsPath)) {
+      // Copy app source files from apps directory
+      await buildCopy.copyAppSourceFiles(appsPath, devDir);
+      logger.log(chalk.green(`✓ Copied application source files from apps/${appName}`));
+    } else {
+      // No apps directory - check if we need to copy template files
+      const language = options.language || buildConfig.language || detectLanguage(devDir);
+      const packageJsonPath = path.join(devDir, 'package.json');
+      const requirementsPath = path.join(devDir, 'requirements.txt');
+
+      if (language === 'typescript' && !fsSync.existsSync(packageJsonPath)) {
+        // Copy TypeScript template files
+        const templatePath = path.join(__dirname, '..', 'templates', 'typescript');
+        await copyTemplateFilesToDevDir(templatePath, devDir, language);
+        logger.log(chalk.green(`✓ Generated application files from ${language} template`));
+      } else if (language === 'python' && !fsSync.existsSync(requirementsPath)) {
+        // Copy Python template files
+        const templatePath = path.join(__dirname, '..', 'templates', 'python');
+        await copyTemplateFilesToDevDir(templatePath, devDir, language);
+        logger.log(chalk.green(`✓ Generated application files from ${language} template`));
+      }
+    }
+
+    // 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;
+
+    // Check if context is using old format (../appName) - these are incompatible with dev directory structure
+    if (buildConfig.context && buildConfig.context.startsWith('../') && buildConfig.context !== '../..') {
+      // Old format detected - always use devDir instead
+      logger.log(chalk.yellow(`⚠️  Warning: Build context uses old format: ${buildConfig.context}`));
+      logger.log(chalk.yellow(`   Using dev directory instead: ${devDir}`));
+      contextPath = devDir;
+    } else 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;
+    }
+
+    // Ensure context path is absolute and normalized
+    contextPath = path.resolve(contextPath);
 
-    // 2. Prepare build context
-    const contextPath = prepareBuildContext(appName, buildConfig.context);
+    // Validate that context path exists (skip in test environments)
+    const isTestEnv = process.env.NODE_ENV === 'test' ||
+                      process.env.JEST_WORKER_ID !== undefined ||
+                      typeof jest !== 'undefined';
 
-    // 3. Check if Dockerfile exists in builder/{appName}/ directory
-    const builderPath = path.join(process.cwd(), 'builder', appName);
-    const appDockerfilePath = path.join(builderPath, 'Dockerfile');
+    if (!isTestEnv && !fsSync.existsSync(contextPath)) {
+      throw new Error(
+        `Build context path does not exist: ${contextPath}\n` +
+        `Expected dev directory: ${devDir}\n` +
+        'Please ensure files were copied correctly or update the context in variables.yaml.'
+      );
+    }
+
+    // 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,17 +437,24 @@ 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
     const tag = options.tag || 'latest';
+
+    // Log paths for debugging
+    logger.log(chalk.blue(`Using Dockerfile: ${dockerfilePath}`));
+    logger.log(chalk.blue(`Using build context: ${contextPath}`));
+
     await executeBuild(imageName, dockerfilePath, contextPath, tag, options);
 
     // 7. Post-build tasks

package/lib/cli.js

@@ -15,10 +15,13 @@ 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');
 const { handleLogin } = require('./commands/login');
+const { handleSecure } = require('./commands/secure');
 
 /**
  * Sets up all CLI commands on the Commander program instance
@@ -28,11 +31,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 +49,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 +154,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 +207,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 +223,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 +323,70 @@ 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);
+      }
+    });
+
+  // Security command
+  program.command('secure')
+    .description('Encrypt secrets in secrets.local.yaml files for ISO 27001 compliance')
+    .option('--secrets-encryption <key>', 'Encryption key (32 bytes, hex or base64)')
+    .action(async(options) => {
+      try {
+        await handleSecure(options);
+      } catch (error) {
+        handleCommandError(error, 'secure');
+        process.exit(1);
+      }
+    });
 }
 
 module.exports = {