@aifabrix/builder 2.22.1 → 2.31.0

package/lib/build.js

@@ -14,75 +14,17 @@ const fs = require('fs').promises;
 const fsSync = require('fs');
 const path = require('path');
 const paths = require('./utils/paths');
-const { detectAppType } = require('./utils/paths');
-const { exec } = require('child_process');
-const { promisify } = require('util');
+const { detectAppType, getProjectRoot } = require('./utils/paths');
 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 { buildDevImageName } = require('./utils/image-name');
-
-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);
-
-    // Skip if source file doesn't exist (e.g., .gitignore might not be in template)
-    try {
-      const entryStats = await fs.stat(sourcePath);
-      if (entryStats.isFile()) {
-        await fs.copyFile(sourcePath, targetPath);
-      }
-    } catch (error) {
-      // Skip files that don't exist (e.g., .gitignore might not be in template)
-      if (error.code !== 'ENOENT') {
-        throw error;
-      }
-    }
-  }
-}
+const buildHelpers = require('./utils/build-helpers');
 
 /**
  * Loads variables.yaml configuration for an application
@@ -235,96 +177,174 @@ async function generateDockerfile(appNameOrPath, language, config, buildConfig =
  * @param {boolean} options.forceTemplate - Force template flag
  * @returns {Promise<string>} Path to Dockerfile
  */
-async function determineDockerfile(appName, options) {
-  // 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(searchPath, appName, options.forceTemplate);
-  if (templateDockerfile) {
-    const relativePath = path.relative(process.cwd(), templateDockerfile);
-    logger.log(chalk.green(`✓ Using existing Dockerfile: ${relativePath}`));
-    return templateDockerfile;
-  }
 
-  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;
-  }
+/**
+ * Executes Docker build and handles tagging
+ * @async
+ * @param {string} imageName - Image name
+ * @param {string} dockerfilePath - Path to Dockerfile
+ * @param {string} contextPath - Build context path
+ * @param {string} tag - Image tag
+ * @param {Object} options - Build options
+ */
 
-  // 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;
+async function postBuildTasks(appName, buildConfig) {
+  try {
+    const envPath = await secrets.generateEnvFile(appName, buildConfig.secrets, 'docker');
+    logger.log(chalk.green(`✓ Generated .env file: ${envPath}`));
+    // Note: processEnvVariables is already called by generateEnvFile to generate local .env
+    // at the envOutputPath, so we don't need to manually copy the docker .env file
+  } catch (error) {
+    logger.log(chalk.yellow(`⚠️  Warning: Could not generate .env file: ${error.message}`));
+  }
 }
 
 /**
- * Loads and validates configuration for build
+ * Check if app is external type and handle accordingly
  * @async
  * @param {string} appName - Application name
- * @returns {Promise<Object>} Configuration object with config, imageName, and buildConfig
- * @throws {Error} If configuration cannot be loaded or validated
+ * @returns {Promise<boolean>} True if external (handled), false if should continue
  */
-async function loadAndValidateConfig(appName) {
+async function checkExternalAppType(appName) {
   const variables = await loadVariablesYaml(appName);
+  if (variables.app && variables.app.type === 'external') {
+    const generator = require('./generator');
+    const jsonPath = await generator.generateDeployJson(appName);
+    logger.log(chalk.green(`✓ Generated deployment JSON: ${jsonPath}`));
+    return true;
+  }
+  return false;
+}
 
-  // Validate configuration
-  const validation = await validator.validateVariables(appName);
-  if (!validation.valid) {
-    throw new Error(`Configuration validation failed:\n${validation.errors.join('\n')}`);
+/**
+ * Prepare dev directory and copy application files
+ * @async
+ * @param {string} appName - Application name
+ * @param {Object} buildConfig - Build configuration
+ * @param {Object} options - Build options
+ * @returns {Promise<Object>} Object with devDir, effectiveImageName, imageName, appConfig, and developerId
+ */
+async function prepareDevDirectory(appName, buildConfig, options) {
+  const developerId = await config.getDeveloperId();
+  const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
+  const directoryName = idNum === 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}`));
+
+  const { config: appConfig, imageName } = await buildHelpers.loadAndValidateConfig(appName);
+  const effectiveImageName = buildDevImageName(imageName, developerId);
+
+  // Check if application source files exist, if not copy from templates
+  const appsPath = path.join(process.cwd(), 'apps', appName);
+  if (fsSync.existsSync(appsPath)) {
+    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)) {
+      const projectRoot = getProjectRoot();
+      const templatePath = path.join(projectRoot, 'templates', 'typescript');
+      await buildCopy.copyTemplateFilesToDevDir(templatePath, devDir, language);
+      logger.log(chalk.green(`✓ Generated application files from ${language} template`));
+    } else if (language === 'python' && !fsSync.existsSync(requirementsPath)) {
+      const projectRoot = getProjectRoot();
+      const templatePath = path.join(projectRoot, 'templates', 'python');
+      await buildCopy.copyTemplateFilesToDevDir(templatePath, devDir, language);
+      logger.log(chalk.green(`✓ Generated application files from ${language} template`));
+    }
   }
 
-  // Extract image name
-  let imageName;
-  if (typeof variables.image === 'string') {
-    imageName = variables.image.split(':')[0];
-  } else if (variables.image?.name) {
-    imageName = variables.image.name;
-  } else if (variables.app?.key) {
-    imageName = variables.app.key;
+  return { devDir, effectiveImageName, imageName, appConfig };
+}
+
+/**
+ * Prepare build context path
+ * @param {Object} buildConfig - Build configuration
+ * @param {string} devDir - Developer directory path
+ * @returns {string} Resolved context path
+ */
+function prepareBuildContext(buildConfig, 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
+    contextPath = process.cwd();
   } else {
-    imageName = appName;
+    // No context specified, use dev directory
+    contextPath = devDir;
   }
 
-  // Extract build config
-  const buildConfig = variables.build || {};
+  // Ensure context path is absolute and normalized
+  contextPath = path.resolve(contextPath);
 
-  return {
-    config: variables,
-    imageName,
-    buildConfig
-  };
+  // 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';
+
+  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.'
+    );
+  }
+
+  return contextPath;
 }
 
 /**
- * Executes Docker build and handles tagging
+ * Handle Dockerfile generation
  * @async
- * @param {string} imageName - Image name
- * @param {string} dockerfilePath - Path to Dockerfile
- * @param {string} contextPath - Build context path
- * @param {string} tag - Image tag
+ * @param {string} appName - Application name
+ * @param {Object} params - Parameters
+ * @param {string} params.devDir - Developer directory
+ * @param {Object} params.buildConfig - Build configuration
+ * @param {string} params.contextPath - Build context path
+ * @param {Object} params.appConfig - Application configuration
  * @param {Object} options - Build options
+ * @returns {Promise<string>} Dockerfile path
  */
-async function executeBuild(imageName, dockerfilePath, contextPath, tag, options) {
-  await dockerBuild.executeDockerBuild(imageName, dockerfilePath, contextPath, tag);
-
-  // Tag image if additional tag provided
-  if (options.tag && options.tag !== 'latest') {
-    await execAsync(`docker tag ${imageName}:${tag} ${imageName}:latest`);
-    logger.log(chalk.green(`✓ Tagged image: ${imageName}:latest`));
+async function handleDockerfileGeneration(appName, params, options, buildHelpers) {
+  const { devDir, buildConfig, contextPath, appConfig } = params;
+  const appDockerfilePath = path.join(devDir, 'Dockerfile');
+  const hasExistingDockerfile = fsSync.existsSync(appDockerfilePath) && !options.forceTemplate;
+
+  // Determine language (skip if existing Dockerfile found)
+  let language = options.language || buildConfig.language;
+  if (!language && !hasExistingDockerfile) {
+    language = detectLanguage(devDir);
+  } else if (!language) {
+    // Default language if existing Dockerfile is found (won't be used, but needed for API)
+    language = 'typescript';
   }
-}
-
-async function postBuildTasks(appName, buildConfig) {
-  try {
-    const envPath = await secrets.generateEnvFile(appName, buildConfig.secrets, 'docker');
-    logger.log(chalk.green(`✓ Generated .env file: ${envPath}`));
-    // Note: processEnvVariables is already called by generateEnvFile to generate local .env
-    // at the envOutputPath, so we don't need to manually copy the docker .env file
-  } catch (error) {
-    logger.log(chalk.yellow(`⚠️  Warning: Could not generate .env file: ${error.message}`));
+  if (!hasExistingDockerfile) {
+    logger.log(chalk.green(`✓ Detected language: ${language}`));
   }
+
+  // Determine Dockerfile (needs context path to generate in correct location)
+  return await buildHelpers.determineDockerfile(appName, {
+    language,
+    config: appConfig,
+    buildConfig,
+    contextPath,
+    forceTemplate: options.forceTemplate,
+    devDir: devDir
+  }, generateDockerfile);
 }
 
 /**
@@ -347,11 +367,7 @@ async function postBuildTasks(appName, buildConfig) {
  */
 async function buildApp(appName, options = {}) {
   // Check if app type is external - generate JSON files only (not deploy)
-  const variables = await loadVariablesYaml(appName);
-  if (variables.app && variables.app.type === 'external') {
-    const generator = require('./generator');
-    const jsonPath = await generator.generateDeployJson(appName);
-    logger.log(chalk.green(`✓ Generated deployment JSON: ${jsonPath}`));
+  if (await checkExternalAppType(appName)) {
     return null;
   }
 
@@ -359,131 +375,27 @@ async function buildApp(appName, options = {}) {
     logger.log(chalk.blue(`\n🔨 Building application: ${appName}`));
 
     // 1. Load and validate configuration
-    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 idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
-    const directoryName = idNum === 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}`));
-    const effectiveImageName = buildDevImageName(imageName, developerId);
-
-    // 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;
-    }
+    const { buildConfig } = await buildHelpers.loadAndValidateConfig(appName);
 
-    // Ensure context path is absolute and normalized
-    contextPath = path.resolve(contextPath);
+    // 2. Prepare dev directory and copy files
+    const { devDir, effectiveImageName, imageName, appConfig } = await prepareDevDirectory(appName, buildConfig, options);
 
-    // 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. Prepare build context
+    const contextPath = prepareBuildContext(buildConfig, devDir);
 
-    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;
-
-    // 5. Determine language (skip if existing Dockerfile found)
-    let language = options.language || buildConfig.language;
-    if (!language && !hasExistingDockerfile) {
-      language = detectLanguage(devDir);
-    } else if (!language) {
-      // Default language if existing Dockerfile is found (won't be used, but needed for API)
-      language = 'typescript';
-    }
-    if (!hasExistingDockerfile) {
-      logger.log(chalk.green(`✓ Detected language: ${language}`));
-    }
-
-    // 6. Determine Dockerfile (needs context path to generate in correct location)
-    // Use dev directory for Dockerfile generation
-    const dockerfilePath = await determineDockerfile(appName, {
-      language,
-      config: appConfig,
+    // 4. Handle Dockerfile generation
+    const dockerfilePath = await handleDockerfileGeneration(appName, {
+      devDir,
       buildConfig,
       contextPath,
-      forceTemplate: options.forceTemplate,
-      devDir: devDir
-    });
+      appConfig
+    }, options, buildHelpers);
 
-    // 6. Build Docker image
+    // 5. Execute Docker build
     const tag = options.tag || 'latest';
+    await dockerBuild.executeDockerBuildWithTag(effectiveImageName, imageName, dockerfilePath, contextPath, tag, options);
 
-    // Log paths for debugging
-    logger.log(chalk.blue(`Using Dockerfile: ${dockerfilePath}`));
-    logger.log(chalk.blue(`Using build context: ${contextPath}`));
-
-    await executeBuild(effectiveImageName, dockerfilePath, contextPath, tag, options);
-    // Back-compat: also tag the built dev image as the base image name
-    try {
-      // Use runtime promisify so tests can capture this call reliably
-      const { promisify } = require('util');
-      const { exec } = require('child_process');
-      const run = promisify(exec);
-      await run(`docker tag ${effectiveImageName}:${tag} ${imageName}:${tag}`);
-      logger.log(chalk.green(`✓ Tagged image: ${imageName}:${tag}`));
-    } catch (err) {
-      logger.log(chalk.yellow(`⚠️  Warning: Could not create compatibility tag ${imageName}:${tag} - ${err.message}`));
-    }
-
-    // 7. Post-build tasks
+    // 6. Post-build tasks
     await postBuildTasks(appName, buildConfig);
 
     logger.log(chalk.green('\n✅ Build completed successfully!'));
@@ -493,5 +405,4 @@ async function buildApp(appName, options = {}) {
     throw new Error(`Build failed: ${error.message}`);
   }
 }
-
-module.exports = { loadVariablesYaml, resolveContextPath, executeDockerBuild: dockerBuild.executeDockerBuild, detectLanguage, generateDockerfile, buildApp, postBuildTasks };
+module.exports = { loadVariablesYaml, resolveContextPath, detectLanguage, generateDockerfile, buildApp, postBuildTasks };

package/lib/cli.js

@@ -21,6 +21,7 @@ const chalk = require('chalk');
 const logger = require('./utils/logger');
 const { validateCommand, handleCommandError } = require('./utils/cli-utils');
 const { handleLogin } = require('./commands/login');
+const { handleLogout } = require('./commands/logout');
 const { handleSecure } = require('./commands/secure');
 const { handleSecretsSet } = require('./commands/secrets-set');
 
@@ -49,6 +50,20 @@ function setupCommands(program) {
       }
     });
 
+  program.command('logout')
+    .description('Clear authentication tokens')
+    .option('-c, --controller <url>', 'Clear device tokens for specific controller')
+    .option('-e, --environment <env>', 'Clear client tokens for specific environment')
+    .option('-a, --app <app>', 'Clear client tokens for specific app (requires --environment)')
+    .action(async(options) => {
+      try {
+        await handleLogout(options);
+      } catch (error) {
+        handleCommandError(error, 'logout');
+        process.exit(1);
+      }
+    });
+
   // Infrastructure commands
   program.command('up')
     .description('Start local infrastructure services (Postgres, Redis, pgAdmin, Redis Commander)')
@@ -474,14 +489,43 @@ function setupCommands(program) {
     });
 
   // Developer configuration commands
-  program.command('dev config')
+  const dev = program
+    .command('dev')
+    .description('Developer configuration and isolation');
+
+  // Helper function to display developer configuration
+  async function displayDevConfig(devId) {
+    const devIdNum = parseInt(devId, 10);
+    const ports = devConfig.getDevPorts(devIdNum);
+    const configVars = [
+      { key: 'aifabrix-home', value: await config.getAifabrixHomeOverride() },
+      { key: 'aifabrix-secrets', value: await config.getAifabrixSecretsPath() },
+      { key: 'aifabrix-env-config', value: await config.getAifabrixEnvConfigPath() }
+    ].filter(v => v.value);
+
+    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}`);
+
+    if (configVars.length > 0) {
+      logger.log('\nConfiguration:');
+      configVars.forEach(v => logger.log(`  ${v.key}: ${v.value}`));
+    }
+    logger.log('');
+  }
+
+  // Config subcommand
+  dev
+    .command('config')
     .description('Show or set developer configuration')
     .option('--set-id <id>', 'Set developer ID')
-    .action(async(cmdName, opts) => {
+    .action(async(options) => {
       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) {
@@ -493,77 +537,41 @@ function setupCommands(program) {
           await config.setDeveloperId(setIdValue);
           process.env.AIFABRIX_DEVELOPERID = setIdValue;
           logger.log(chalk.green(`✓ Developer ID set to ${setIdValue}`));
-          // Convert to number only for getDevPorts (which requires a number)
-          const devIdNum = parseInt(setIdValue, 10);
           // Use the ID we just set instead of reading from file to avoid race conditions
-          const ports = devConfig.getDevPorts(devIdNum);
-          logger.log('\n🔧 Developer Configuration\n');
-          logger.log(`Developer ID: ${setIdValue}`);
-          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}`);
-
-          // Display configuration variables if set
-          const aifabrixHome = await config.getAifabrixHomeOverride();
-          const aifabrixSecrets = await config.getAifabrixSecretsPath();
-          const aifabrixEnvConfig = await config.getAifabrixEnvConfigPath();
-
-          if (aifabrixHome || aifabrixSecrets || aifabrixEnvConfig) {
-            logger.log('\nConfiguration:');
-            if (aifabrixHome) {
-              logger.log(`  aifabrix-home: ${aifabrixHome}`);
-            }
-            if (aifabrixSecrets) {
-              logger.log(`  aifabrix-secrets: ${aifabrixSecrets}`);
-            }
-            if (aifabrixEnvConfig) {
-              logger.log(`  aifabrix-env-config: ${aifabrixEnvConfig}`);
-            }
-          }
-          logger.log('');
+          await displayDevConfig(setIdValue);
           return;
         }
 
         const devId = await config.getDeveloperId();
-        // Convert string developer ID to number for getDevPorts
-        const devIdNum = parseInt(devId, 10);
-        const ports = devConfig.getDevPorts(devIdNum);
-        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}`);
-
-        // Display configuration variables if set
-        const aifabrixHome = await config.getAifabrixHomeOverride();
-        const aifabrixSecrets = await config.getAifabrixSecretsPath();
-        const aifabrixEnvConfig = await config.getAifabrixEnvConfigPath();
-
-        if (aifabrixHome || aifabrixSecrets || aifabrixEnvConfig) {
-          logger.log('\nConfiguration:');
-          if (aifabrixHome) {
-            logger.log(`  aifabrix-home: ${aifabrixHome}`);
-          }
-          if (aifabrixSecrets) {
-            logger.log(`  aifabrix-secrets: ${aifabrixSecrets}`);
-          }
-          if (aifabrixEnvConfig) {
-            logger.log(`  aifabrix-env-config: ${aifabrixEnvConfig}`);
-          }
-        }
-        logger.log('');
+        await displayDevConfig(devId);
       } catch (error) {
         handleCommandError(error, 'dev config');
         process.exit(1);
       }
     });
 
+  // Set-id subcommand
+  dev
+    .command('set-id <id>')
+    .description('Set developer ID (convenience alias for "dev config --set-id")')
+    .action(async(id) => {
+      try {
+        const digitsOnly = /^[0-9]+$/.test(id);
+        if (!digitsOnly) {
+          throw new Error('Developer ID must be a non-negative digit string (0 = default infra, > 0 = developer-specific)');
+        }
+        // Preserve the original string value to maintain leading zeros (e.g., "01")
+        await config.setDeveloperId(id);
+        process.env.AIFABRIX_DEVELOPERID = id;
+        logger.log(chalk.green(`✓ Developer ID set to ${id}`));
+        // Use the ID we just set instead of reading from file to avoid race conditions
+        await displayDevConfig(id);
+      } catch (error) {
+        handleCommandError(error, 'dev set-id');
+        process.exit(1);
+      }
+    });
+
   // Secrets management commands
   const secretsCmd = program
     .command('secrets')