@aifabrix/builder 2.41.0 → 2.42.0

package/lib/generator/wizard.js

@@ -15,7 +15,8 @@ const chalk = require('chalk');
 const logger = require('../utils/logger');
 const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
 const { loadConfigFile, writeConfigFile } = require('../utils/config-format');
-const { generateExternalReadmeContent } = require('../utils/external-readme');
+const { systemKeyToKvPrefix } = require('../utils/credential-secrets-env');
+const { generateReadme } = require('./wizard-readme');
 
 /**
  * Converts a string to a schema-valid key segment (lowercase letters, numbers, hyphens only).
@@ -41,45 +42,59 @@ function toKeySegment(str) {
  * @returns {Promise<Object>} Object with generated file paths
  * @throws {Error} If file generation fails
  */
+/** Extension for format */
+const FORMAT_EXT = { yaml: '.yaml', json: '.json' };
+
 /**
- * Writes system JSON file
+ * Writes system config file
  * @async
  * @function writeSystemYamlFile
  * @param {string} appPath - Application path
  * @param {string} finalSystemKey - Final system key
  * @param {Object} systemConfig - System configuration
+ * @param {string} [format] - Output format: 'yaml' (default) or 'json'
  * @returns {Promise<string>} System file path
  */
-async function writeSystemYamlFile(appPath, finalSystemKey, systemConfig) {
-  const systemFileName = `${finalSystemKey}-system.yaml`;
+async function writeSystemYamlFile(appPath, finalSystemKey, systemConfig, format = 'yaml') {
+  const ext = FORMAT_EXT[format === 'json' ? 'json' : 'yaml'] || '.yaml';
+  const systemFileName = `${finalSystemKey}-system${ext}`;
   const systemFilePath = path.join(appPath, systemFileName);
-  writeConfigFile(systemFilePath, systemConfig);
+  writeConfigFile(systemFilePath, systemConfig, format === 'json' ? 'json' : 'yaml');
   logger.log(chalk.green(`✓ Generated system file: ${systemFileName}`));
   return systemFilePath;
 }
 
 /**
- * Writes datasource YAML files
+ * Writes datasource config files
  * @async
  * @function writeDatasourceYamlFiles
  * @param {string} appPath - Application path
  * @param {string} finalSystemKey - Final system key
  * @param {Object[]} datasourceConfigs - Array of datasource configurations
+ * @param {string} [format] - Output format: 'yaml' (default) or 'json'
  * @returns {Promise<string[]>} Array of datasource file names
  */
-async function writeDatasourceYamlFiles(appPath, finalSystemKey, datasourceConfigs) {
+async function writeDatasourceYamlFiles(appPath, finalSystemKey, datasourceConfigs, format = 'yaml') {
+  const ext = FORMAT_EXT[format === 'json' ? 'json' : 'yaml'] || '.yaml';
+  const fmt = format === 'json' ? 'json' : 'yaml';
   const datasourceFileNames = [];
+  const usedBaseNames = new Set();
   for (const datasourceConfig of datasourceConfigs) {
-    const entityType = datasourceConfig.entityType || datasourceConfig.entityKey || datasourceConfig.key?.split('-').pop() || 'default';
-    const keySegment = toKeySegment(entityType);
-    const datasourceKey = datasourceConfig.key || `${finalSystemKey}-${keySegment}`;
-    // Extract datasource key (remove system key prefix if present); use normalized segment for filename
+    const datasourceKey = datasourceConfig.key || '';
     const datasourceKeyOnly = datasourceKey.includes('-') && datasourceKey.startsWith(`${finalSystemKey}-`)
       ? datasourceKey.substring(finalSystemKey.length + 1)
-      : keySegment;
-    const datasourceFileName = `${finalSystemKey}-datasource-${datasourceKeyOnly}.yaml`;
+      : (datasourceConfig.entityType || datasourceConfig.entityKey || datasourceKey.split('-').pop() || 'default');
+    const keySegment = toKeySegment(datasourceKeyOnly);
+    let baseName = keySegment;
+    if (usedBaseNames.has(baseName)) {
+      let suffix = 1;
+      while (usedBaseNames.has(`${baseName}-${suffix}`)) suffix++;
+      baseName = `${baseName}-${suffix}`;
+    }
+    usedBaseNames.add(baseName);
+    const datasourceFileName = `${finalSystemKey}-datasource-${baseName}${ext}`;
     const datasourceFilePath = path.join(appPath, datasourceFileName);
-    writeConfigFile(datasourceFilePath, datasourceConfig);
+    writeConfigFile(datasourceFilePath, datasourceConfig, fmt);
     datasourceFileNames.push(datasourceFileName);
     logger.log(chalk.green(`✓ Generated datasource file: ${datasourceFileName}`));
   }
@@ -102,20 +117,21 @@ async function writeDatasourceYamlFiles(appPath, finalSystemKey, datasourceConfi
  * @returns {Promise<Object>} Object with file paths
  */
 async function generateConfigFilesForWizard(params) {
-  const { appPath, appName, finalSystemKey, systemFileName, datasourceFileNames, systemConfig, datasourceConfigs, aiGeneratedReadme } = params;
+  const { appPath, appName, finalSystemKey, systemFileName, datasourceFileNames, systemConfig, datasourceConfigs, aiGeneratedReadme, format } = params;
 
-  // Generate or update application.yaml with externalIntegration block
+  // Generate or update application config with externalIntegration block
   const configPath = await generateOrUpdateVariablesYaml({
     appPath,
     appName,
     systemKey: finalSystemKey,
     systemFileName,
     datasourceFileNames,
-    systemConfig
+    systemConfig,
+    format: format || 'yaml'
   });
 
-  // Generate env.template with authentication variables
-  await generateEnvTemplate(appPath, systemConfig);
+  // Generate env.template with KV_* authentication variables
+  await generateEnvTemplate(appPath, systemConfig, finalSystemKey);
 
   const envTemplatePath = path.join(appPath, 'env.template');
   try {
@@ -126,16 +142,25 @@ async function generateConfigFilesForWizard(params) {
   }
 
   // Generate README.md (use AI-generated content if available)
-  await generateReadme(appPath, appName, finalSystemKey, systemConfig, datasourceConfigs, aiGeneratedReadme);
+  await generateReadme({
+    appPath,
+    appName,
+    systemKey: finalSystemKey,
+    systemConfig,
+    datasourceConfigs,
+    aiGeneratedContent: aiGeneratedReadme,
+    format
+  });
 
   // Generate deployment scripts
   const deployScripts = await generateDeployScripts(appPath, finalSystemKey, systemFileName, datasourceFileNames);
 
   // Generate deployment manifest (<systemKey>-deploy.json) using controller format
-  const { generateControllerManifest } = require('./external-controller-manifest');
+  const { generateControllerManifest, toDeployJsonShape } = require('./external-controller-manifest');
   const manifest = await generateControllerManifest(appName, { appPath });
+  const deployJson = toDeployJsonShape(manifest);
   const deployManifestPath = path.join(appPath, `${finalSystemKey}-deploy.json`);
-  await fs.writeFile(deployManifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+  await fs.writeFile(deployManifestPath, JSON.stringify(deployJson, null, 2), 'utf8');
   logger.log(chalk.green(`✓ Generated deployment manifest: ${finalSystemKey}-deploy.json`));
 
   return {
@@ -151,24 +176,40 @@ async function prepareWizardContext(appName, systemConfig, datasourceConfigs) {
   const appPath = path.join(process.cwd(), 'integration', appName);
   await fs.mkdir(appPath, { recursive: true });
   const finalSystemKey = appName;
+  const originalSystemKey = systemConfig.key || finalSystemKey;
   const appDisplayName = appName.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
   const updatedSystemConfig = { ...systemConfig, key: finalSystemKey, displayName: appDisplayName };
+  const originalPrefix = `${originalSystemKey}-`;
   const updatedDatasourceConfigs = datasourceConfigs.map(ds => {
-    const entityType = ds.entityType || ds.entityKey || ds.key?.split('-').pop() || 'default';
-    const keySegment = toKeySegment(entityType);
-    const entityDisplayName = entityType.charAt(0).toUpperCase() + entityType.slice(1).replace(/-/g, ' ');
-    return { ...ds, key: `${finalSystemKey}-${keySegment}`, systemKey: finalSystemKey, displayName: `${appDisplayName} ${entityDisplayName}` };
+    let newKey;
+    const dsKey = ds.key || '';
+    if (dsKey && dsKey.startsWith(originalPrefix)) {
+      newKey = `${finalSystemKey}-${dsKey.substring(originalPrefix.length)}`;
+    } else {
+      const entityType = ds.entityType || ds.entityKey || dsKey.split('-').pop() || 'default';
+      const keySegment = toKeySegment(entityType);
+      newKey = `${finalSystemKey}-${keySegment}`;
+    }
+    const entityType = ds.entityType || ds.entityKey || newKey.split('-').pop() || 'default';
+    const entityDisplayName = String(entityType).charAt(0).toUpperCase() + String(entityType).slice(1).replace(/-/g, ' ');
+    return { ...ds, key: newKey, systemKey: finalSystemKey, displayName: ds.displayName || `${appDisplayName} ${entityDisplayName}` };
   });
   return { appPath, finalSystemKey, updatedSystemConfig, updatedDatasourceConfigs, appDisplayName };
 }
 
 async function generateWizardFiles(appName, systemConfig, datasourceConfigs, systemKey, options = {}) {
   try {
-    const { aiGeneratedReadme } = options || {};
+    const { aiGeneratedReadme, format } = options || {};
+    const fmt = format === 'json' ? 'json' : 'yaml';
+    const ext = FORMAT_EXT[fmt] || '.yaml';
     const { appPath, finalSystemKey, updatedSystemConfig, updatedDatasourceConfigs } = await prepareWizardContext(appName, systemConfig, datasourceConfigs);
-    const systemFilePath = await writeSystemYamlFile(appPath, finalSystemKey, updatedSystemConfig);
-    const datasourceFileNames = await writeDatasourceYamlFiles(appPath, finalSystemKey, updatedDatasourceConfigs);
-    const systemFileName = `${finalSystemKey}-system.yaml`;
+    const systemConfigWithDataSourcesKeys = {
+      ...updatedSystemConfig,
+      dataSources: updatedDatasourceConfigs.map(ds => ds.key)
+    };
+    const systemFilePath = await writeSystemYamlFile(appPath, finalSystemKey, systemConfigWithDataSourcesKeys, fmt);
+    const datasourceFileNames = await writeDatasourceYamlFiles(appPath, finalSystemKey, updatedDatasourceConfigs, fmt);
+    const systemFileName = `${finalSystemKey}-system${ext}`;
     const configFiles = await generateConfigFilesForWizard({
       appPath,
       appName,
@@ -177,7 +218,8 @@ async function generateWizardFiles(appName, systemConfig, datasourceConfigs, sys
       datasourceFileNames,
       systemConfig: updatedSystemConfig,
       datasourceConfigs: updatedDatasourceConfigs,
-      aiGeneratedReadme
+      aiGeneratedReadme,
+      format: fmt
     });
     return {
       appPath,
@@ -190,22 +232,48 @@ async function generateWizardFiles(appName, systemConfig, datasourceConfigs, sys
   }
 }
 
+function mergeAppAndExternalIntegration(variables, appName, systemFileName, datasourceFileNames, systemConfig) {
+  if (!variables.app) {
+    variables.app = {
+      key: appName,
+      displayName: systemConfig.displayName || appName.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase()),
+      description: systemConfig.description || `External system integration for ${appName}`,
+      type: 'external',
+      version: '1.0.0'
+    };
+  } else {
+    variables.app.version = variables.app.version || '1.0.0';
+  }
+  if (!variables.deployment) {
+    variables.deployment = { controllerUrl: '', environment: 'dev' };
+  }
+  variables.externalIntegration = {
+    schemaBasePath: './',
+    systems: [systemFileName],
+    dataSources: datasourceFileNames,
+    autopublish: true,
+    version: systemConfig.version || '1.0.0'
+  };
+}
+
 /**
- * Generate or update application.yaml with externalIntegration block
+ * Generate or update application config with externalIntegration block
  * @async
  * @function generateOrUpdateVariablesYaml
  * @param {Object} params - Parameters object
  * @param {string} params.appPath - Application directory path
  * @param {string} params.appName - Application name
- * @param {string} params.systemKey - System key
  * @param {string} params.systemFileName - System file name
  * @param {string[]} params.datasourceFileNames - Array of datasource file names
  * @param {Object} params.systemConfig - System configuration
+ * @param {string} [params.format] - Output format: 'yaml' (default) or 'json'
  * @returns {Promise<string>} Path to application config file
  * @throws {Error} If generation fails
  */
 async function generateOrUpdateVariablesYaml(params) {
-  const { appPath, appName, systemFileName, datasourceFileNames, systemConfig } = params;
+  const { appPath, appName, systemFileName, datasourceFileNames, systemConfig, format } = params;
+  const fmt = format === 'json' ? 'json' : 'yaml';
+  const ext = FORMAT_EXT[fmt] || '.yaml';
   let configPath;
   let variables = {};
   try {
@@ -213,115 +281,88 @@ async function generateOrUpdateVariablesYaml(params) {
       configPath = resolveApplicationConfigPath(appPath);
       variables = loadConfigFile(configPath) || {};
     } catch {
-      configPath = path.join(appPath, 'application.yaml');
-    }
-
-    // Set basic app info if not present
-    if (!variables.app) {
-      variables.app = {
-        key: appName,
-        displayName: systemConfig.displayName || appName.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase()),
-        description: systemConfig.description || `External system integration for ${appName}`,
-        type: 'external',
-        version: '1.0.0'
-      };
-    } else {
-      variables.app.version = variables.app.version || '1.0.0';
+      configPath = path.join(appPath, `application${ext}`);
     }
-
-    // Set deployment config if not present
-    if (!variables.deployment) {
-      variables.deployment = {
-        controllerUrl: '',
-        environment: 'dev'
-      };
+    mergeAppAndExternalIntegration(variables, appName, systemFileName, datasourceFileNames, systemConfig);
+    const targetPath = path.join(appPath, `application${ext}`);
+    writeConfigFile(targetPath, variables, fmt);
+    if (path.normalize(configPath) !== path.normalize(targetPath)) {
+      const fsSync = require('fs');
+      if (fsSync.existsSync(configPath)) fsSync.unlinkSync(configPath);
     }
-
-    // Add or update externalIntegration block
-    variables.externalIntegration = {
-      schemaBasePath: './',
-      systems: [systemFileName],
-      dataSources: datasourceFileNames,
-      autopublish: true,
-      version: systemConfig.version || '1.0.0'
-    };
-
-    writeConfigFile(configPath, variables);
-    logger.log(chalk.green('✓ Generated/updated application.yaml'));
-    return configPath;
+    logger.log(chalk.green(`✓ Generated/updated application${ext}`));
+    return targetPath;
   } catch (error) {
     throw new Error(`Failed to generate application config: ${error.message}`);
   }
 }
 
 /**
- * Adds API key authentication lines to env template
- * @function addApiKeyAuthLines
+ * Adds API key authentication lines with KV_* convention
  * @param {Array<string>} lines - Lines array to append to
+ * @param {string} prefix - KV prefix (e.g. HUBSPOT)
  */
-function addApiKeyAuthLines(lines) {
+function addApiKeyAuthLines(lines, prefix) {
   lines.push('# API Key Authentication');
-  lines.push('API_KEY=kv://secrets/api-key');
+  lines.push(`KV_${prefix}_APIKEY=`);
   lines.push('');
 }
 
 /**
- * Adds OAuth2 authentication lines to env template
- * @function addOAuth2AuthLines
+ * Adds OAuth2 authentication lines with KV_* convention
  * @param {Array<string>} lines - Lines array to append to
  * @param {Object} auth - Authentication configuration
+ * @param {string} prefix - KV prefix
  */
-function addOAuth2AuthLines(lines, auth) {
+function addOAuth2AuthLines(lines, auth, prefix) {
   lines.push('# OAuth2 Authentication');
-  lines.push('CLIENT_ID=kv://secrets/client-id');
-  lines.push('CLIENT_SECRET=kv://secrets/client-secret');
-  lines.push('AUTH_URL=kv://secrets/auth-url');
-  lines.push('TOKEN_URL=kv://secrets/token-url');
-  if (auth.scope) {
-    lines.push(`SCOPE=${auth.scope}`);
-  }
+  lines.push(`KV_${prefix}_CLIENTID=`);
+  lines.push(`KV_${prefix}_CLIENTSECRET=`);
+  if (auth.scope) lines.push(`SCOPE=${auth.scope}`);
   lines.push('');
 }
 
 /**
- * Adds bearer token authentication lines to env template
- * @function addBearerTokenAuthLines
+ * Adds bearer token authentication lines with KV_* convention
  * @param {Array<string>} lines - Lines array to append to
+ * @param {string} prefix - KV prefix
  */
-function addBearerTokenAuthLines(lines) {
+function addBearerTokenAuthLines(lines, prefix) {
   lines.push('# Bearer Token Authentication');
-  lines.push('BEARER_TOKEN=kv://secrets/bearer-token');
+  lines.push(`KV_${prefix}_BEARERTOKEN=`);
   lines.push('');
 }
 
 /**
- * Adds basic authentication lines to env template
- * @function addBasicAuthLines
+ * Adds basic authentication lines with KV_* convention
  * @param {Array<string>} lines - Lines array to append to
+ * @param {string} prefix - KV prefix
  */
-function addBasicAuthLines(lines) {
+function addBasicAuthLines(lines, prefix) {
   lines.push('# Basic Authentication');
-  lines.push('USERNAME=kv://secrets/username');
-  lines.push('PASSWORD=kv://secrets/password');
+  lines.push(`KV_${prefix}_USERNAME=`);
+  lines.push(`KV_${prefix}_PASSWORD=`);
   lines.push('');
 }
 
 /**
- * Adds authentication lines based on auth type
- * @function addAuthenticationLines
+ * Adds authentication lines based on auth type. Uses KV_<APPKEY>_<VAR> convention.
  * @param {Array<string>} lines - Lines array to append to
  * @param {Object} auth - Authentication configuration
  * @param {string} authType - Authentication type
+ * @param {string} systemKey - System key (e.g. hubspot) for KV_ prefix
  */
-function addAuthenticationLines(lines, auth, authType) {
+function addAuthenticationLines(lines, auth, authType, systemKey) {
+  const prefix = systemKeyToKvPrefix(systemKey);
+  if (!prefix) return;
   if (authType === 'apikey' || authType === 'apiKey') {
-    addApiKeyAuthLines(lines);
+    addApiKeyAuthLines(lines, prefix);
   } else if (authType === 'oauth2' || authType === 'oauth') {
-    addOAuth2AuthLines(lines, auth);
+    addOAuth2AuthLines(lines, auth || {}, prefix);
   } else if (authType === 'bearer' || authType === 'token') {
-    addBearerTokenAuthLines(lines);
+    addBearerTokenAuthLines(lines, prefix);
   } else if (authType === 'basic') {
-    addBasicAuthLines(lines);
+    addBasicAuthLines(lines, prefix);
   }
 }
 
@@ -340,23 +381,24 @@ function addBaseUrlLines(lines, systemConfig) {
 }
 
 /**
- * Generate env.template with authentication variables
+ * Generate env.template with KV_* authentication variables
  * @async
  * @function generateEnvTemplate
  * @param {string} appPath - Application directory path
- * @param {Object} systemConfig - System configuration
+ * @param {Object} systemConfig - System configuration (must have key for systemKey)
+ * @param {string} [finalSystemKey] - Final system key for KV_ prefix (default: systemConfig.key)
  * @throws {Error} If generation fails
  */
-async function generateEnvTemplate(appPath, systemConfig) {
+async function generateEnvTemplate(appPath, systemConfig, finalSystemKey) {
   try {
     const envTemplatePath = path.join(appPath, 'env.template');
-    const lines = ['# Environment variables for external system integration', ''];
+    const systemKey = finalSystemKey || systemConfig?.key;
+    const lines = ['# Environment variables for external system integration', '# Use KV_* for credential push (aifabrix credential push)', ''];
 
-    // Extract authentication variables from system config
-    const auth = systemConfig.authentication || systemConfig.auth || {};
+    const auth = systemConfig?.authentication || systemConfig?.auth || {};
     const authType = auth.type || auth.authType || 'apikey';
 
-    addAuthenticationLines(lines, auth, authType);
+    addAuthenticationLines(lines, auth, authType, systemKey);
     addBaseUrlLines(lines, systemConfig);
 
     await fs.writeFile(envTemplatePath, lines.join('\n'), 'utf8');
@@ -401,59 +443,6 @@ async function generateDeployScripts(appPath, systemKey, systemFileName, datasou
   }
 }
 
-/**
- * Generate README.md with basic documentation
- * @async
- * @function generateReadme
- * @param {string} appPath - Application directory path
- * @param {string} appName - Application name
- * @param {string} systemKey - System key
- * @param {Object} systemConfig - System configuration
- * @param {Object[]} datasourceConfigs - Array of datasource configurations
- * @param {string} [aiGeneratedContent] - Optional AI-generated README content from dataplane
- * @throws {Error} If generation fails
- */
-async function generateReadme(appPath, appName, systemKey, systemConfig, datasourceConfigs, aiGeneratedContent) {
-  try {
-    const readmePath = path.join(appPath, 'README.md');
-
-    // Use AI-generated content if available, otherwise generate basic README
-    if (aiGeneratedContent) {
-      await fs.writeFile(readmePath, aiGeneratedContent, 'utf8');
-      logger.log(chalk.green('✓ Generated README.md (AI-generated from dataplane)'));
-      return;
-    }
-
-    const datasources = (Array.isArray(datasourceConfigs) ? datasourceConfigs : []).map((ds, index) => {
-      const entityType = ds.entityType || ds.entityKey || ds.key?.split('-').pop() || `datasource${index + 1}`;
-      const keySegment = toKeySegment(entityType);
-      const datasourceKey = ds.key || `${systemKey}-${keySegment}`;
-      const datasourceKeyOnly = datasourceKey.includes('-') && datasourceKey.startsWith(`${systemKey}-`)
-        ? datasourceKey.substring(systemKey.length + 1)
-        : keySegment;
-      return {
-        entityType,
-        displayName: ds.displayName || ds.name || ds.key || `Datasource ${index + 1}`,
-        fileName: `${systemKey}-datasource-${datasourceKeyOnly}.yaml`
-      };
-    });
-
-    const readmeContent = generateExternalReadmeContent({
-      appName,
-      systemKey,
-      systemType: systemConfig.type || systemConfig.systemType,
-      displayName: systemConfig.displayName,
-      description: systemConfig.description,
-      datasources
-    });
-
-    await fs.writeFile(readmePath, readmeContent, 'utf8');
-    logger.log(chalk.green('✓ Generated README.md (template)'));
-  } catch (error) {
-    throw new Error(`Failed to generate README.md: ${error.message}`);
-  }
-}
-
 module.exports = {
   generateWizardFiles,
   generateDeployScripts

package/lib/infrastructure/compose.js

@@ -63,6 +63,8 @@ function validateTraefikConfig(traefikConfig) {
  * @param {string} infraDir - Infrastructure directory
  * @param {Object} [options] - Additional options
  * @param {Object|boolean} [options.traefik] - Traefik configuration
+ * @param {Object} [options.pgadmin] - pgAdmin config { enabled: boolean }
+ * @param {Object} [options.redisCommander] - Redis Commander config { enabled: boolean }
  * @returns {string} Path to generated compose file
  */
 function generateComposeFile(templatePath, devId, idNum, ports, infraDir, options = {}) {
@@ -74,6 +76,12 @@ function generateComposeFile(templatePath, devId, idNum, ports, infraDir, option
   const traefikConfig = typeof options.traefik === 'object'
     ? options.traefik
     : buildTraefikConfig(!!options.traefik);
+  const pgadminConfig = options.pgadmin && typeof options.pgadmin.enabled === 'boolean'
+    ? options.pgadmin
+    : { enabled: true };
+  const redisCommanderConfig = options.redisCommander && typeof options.redisCommander.enabled === 'boolean'
+    ? options.redisCommander
+    : { enabled: true };
   const composeContent = template({
     devId: devId,
     postgresPort: ports.postgres,
@@ -86,7 +94,9 @@ function generateComposeFile(templatePath, devId, idNum, ports, infraDir, option
     serversJsonPath: serversJsonPath,
     pgpassPath: pgpassPath,
     infraDir: infraDir,
-    traefik: traefikConfig
+    traefik: traefikConfig,
+    pgadmin: pgadminConfig,
+    redisCommander: redisCommanderConfig
   });
   const composePath = path.join(infraDir, 'compose.yaml');
   fs.writeFileSync(composePath, composeContent);

package/lib/infrastructure/index.js

@@ -89,7 +89,7 @@ async function prepareInfrastructureEnvironment(developerId, options = {}) {
  */
 async function startInfra(developerId = null, options = {}) {
   const { devId, idNum, ports, templatePath, infraDir } = await prepareInfrastructureEnvironment(developerId, options);
-  const { traefik = false } = options;
+  const { traefik = false, pgadmin = true, redisCommander = true } = options;
   const traefikConfig = buildTraefikConfig(traefik);
   const validation = validateTraefikConfig(traefikConfig);
   if (!validation.valid) {
@@ -100,10 +100,18 @@ async function startInfra(developerId = null, options = {}) {
   registerHandlebarsHelper();
 
   // Generate compose file
-  const composePath = generateComposeFile(templatePath, devId, idNum, ports, infraDir, { traefik: traefikConfig });
+  const composePath = generateComposeFile(templatePath, devId, idNum, ports, infraDir, {
+    traefik: traefikConfig,
+    pgadmin: { enabled: !!pgadmin },
+    redisCommander: { enabled: !!redisCommander }
+  });
 
   try {
-    await startDockerServicesAndConfigure(composePath, devId, idNum, infraDir);
+    await startDockerServicesAndConfigure(composePath, devId, idNum, infraDir, {
+      pgadmin: !!pgadmin,
+      redisCommander: !!redisCommander,
+      traefik: !!traefik
+    });
   } finally {
     // Keep the compose file for stop commands
   }

package/lib/infrastructure/services.js

@@ -123,7 +123,7 @@ function cleanupRunFiles(runEnvPath, pgpassRunPath) {
 }
 
 /**
- * Starts Docker services and configures pgAdmin.
+ * Starts Docker services and configures pgAdmin (when enabled).
  * Writes decrypted admin secrets to a temporary .env in infra dir, runs compose, then deletes the file (ISO 27K).
  *
  * @async
@@ -132,11 +132,13 @@ function cleanupRunFiles(runEnvPath, pgpassRunPath) {
  * @param {string} devId - Developer ID
  * @param {number} idNum - Developer ID number
  * @param {string} infraDir - Infrastructure directory
+ * @param {Object} [opts] - Options (pgadmin, redisCommander, traefik)
  */
-async function startDockerServicesAndConfigure(composePath, devId, idNum, infraDir) {
+async function startDockerServicesAndConfigure(composePath, devId, idNum, infraDir, opts = {}) {
   let runEnvPath;
   let pgpassRunPath;
   let adminObj;
+  const { pgadmin = true, redisCommander = true, traefik = false } = opts;
   try {
     ({ adminObj, runEnvPath } = await prepareRunEnv(infraDir));
   } catch (err) {
@@ -146,8 +148,10 @@ async function startDockerServicesAndConfigure(composePath, devId, idNum, infraD
   try {
     const projectName = getInfraProjectName(devId);
     await startDockerServices(composePath, projectName, runEnvPath, infraDir);
-    pgpassRunPath = await writePgpassAndCopyPgAdminConfig(infraDir, adminObj, devId, idNum);
-    await waitForServices(devId);
+    if (pgadmin) {
+      pgpassRunPath = await writePgpassAndCopyPgAdminConfig(infraDir, adminObj, devId, idNum);
+    }
+    await waitForServices(devId, { pgadmin, redisCommander, traefik });
     logger.log('All services are healthy and ready');
   } finally {
     cleanupRunFiles(runEnvPath, pgpassRunPath);
@@ -157,14 +161,16 @@ async function startDockerServicesAndConfigure(composePath, devId, idNum, infraD
 /**
  * Waits for services to be healthy
  * @private
- * @param {number} [devId] - Developer ID (optional, will be loaded from config if not provided)
+ * @param {number|string|null} [devId] - Developer ID (optional, will be loaded from config if not provided)
+ * @param {Object} [opts] - Options (pgadmin, redisCommander, traefik) - which optional services to expect
  */
-async function waitForServices(devId = null) {
+async function waitForServices(devId = null, opts = {}) {
   const maxAttempts = 30;
   const delay = 2000; // 2 seconds
+  const { pgadmin = true, redisCommander = true, traefik = false } = opts;
 
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    const health = await checkInfraHealth(devId);
+    const health = await checkInfraHealth(devId, { pgadmin, redisCommander, traefik });
     const allHealthy = Object.values(health).every(status => status === 'healthy');
 
     if (allHealthy) {
@@ -182,15 +188,17 @@ async function waitForServices(devId = null) {
 
 /**
  * Checks if infrastructure services are running
- * Validates that all required services are healthy and accessible
+ * Validates that all expected services are healthy and accessible
  *
  * @async
  * @function checkInfraHealth
  * @param {number|string|null} [devId] - Developer ID (null = use current)
  * @param {Object} [options] - Options
  * @param {boolean} [options.strict=false] - When true, only consider current dev's containers (no fallback to dev 0); use for up-miso and status consistency
+ * @param {boolean} [options.pgadmin=true] - Include pgAdmin in health check
+ * @param {boolean} [options.redisCommander=true] - Include Redis Commander in health check
+ * @param {boolean} [options.traefik=false] - Include Traefik in health check
  * @returns {Promise<Object>} Health status of each service
- * @throws {Error} If health check fails
  *
  * @example
  * const health = await checkInfraHealth();
@@ -199,7 +207,10 @@ async function waitForServices(devId = null) {
 async function checkInfraHealth(devId = null, options = {}) {
   const developerId = devId || await config.getDeveloperId();
   const servicesWithHealthCheck = ['postgres', 'redis'];
-  const servicesWithoutHealthCheck = ['pgadmin', 'redis-commander'];
+  const servicesWithoutHealthCheck = [];
+  if (options.pgadmin !== false) servicesWithoutHealthCheck.push('pgadmin');
+  if (options.redisCommander !== false) servicesWithoutHealthCheck.push('redis-commander');
+  if (options.traefik === true) servicesWithoutHealthCheck.push('traefik');
   const health = {};
   const lookupOptions = options.strict ? { strict: true } : {};
 
@@ -208,7 +219,7 @@ async function checkInfraHealth(devId = null, options = {}) {
     health[service] = await containerUtils.checkServiceWithHealthCheck(service, developerId, lookupOptions);
   }
 
-  // Check if services without health checks are running
+  // Check if optional services without health checks are running
   for (const service of servicesWithoutHealthCheck) {
     health[service] = await containerUtils.checkServiceWithoutHealthCheck(service, developerId, lookupOptions);
   }