@aifabrix/builder 2.31.1 → 2.32.2

package/lib/app/index.js

@@ -0,0 +1,298 @@
+/**
+ * AI Fabrix Builder Application Management
+ *
+ * This module handles application building, running, and deployment.
+ * Includes runtime detection, Dockerfile generation, and container management.
+ *
+ * @fileoverview Application build and run management for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs').promises;
+const { readExistingEnv } = require('../core/env-reader');
+const build = require('../build');
+const appRun = require('./run');
+const { promptForOptions } = require('./prompts');
+const { generateConfigFiles } = require('./config');
+const { pushApp } = require('./push');
+const { generateDockerfileForApp } = require('./dockerfile');
+const { loadTemplateVariables, updateTemplateVariables, mergeTemplateVariables } = require('../utils/template-helpers');
+const { validateTemplate } = require('../validation/template');
+const auditLogger = require('../core/audit-logger');
+const { downApp } = require('./down');
+const { getAppPath } = require('../utils/paths');
+const { displaySuccessMessage } = require('./display');
+const {
+  validateAppDirectoryNotExists,
+  getBaseDirForAppType,
+  handleGitHubWorkflows,
+  validateAppCreation,
+  processTemplateFiles,
+  setupAppFiles
+} = require('./helpers');
+
+/**
+ * Creates new application with scaffolded configuration files
+ * Prompts for configuration options and generates builder/ folder structure
+ *
+ * @async
+ * @function createApp
+ * @param {string} appName - Name of the application to create
+ * @param {Object} options - Creation options
+ * @param {number} [options.port] - Application port
+ * @param {boolean} [options.database] - Requires database
+ * @param {boolean} [options.redis] - Requires Redis
+ * @param {boolean} [options.storage] - Requires file storage
+ * @param {boolean} [options.authentication] - Requires authentication/RBAC
+ * @param {string} [options.language] - Runtime language (typescript/python)
+ * @param {string} [options.template] - Template to use (e.g., controller, keycloak)
+ * @returns {Promise<void>} Resolves when app is created
+ * @throws {Error} If creation fails
+ *
+ * @example
+ * await createApp('myapp', { port: 3000, database: true, language: 'typescript' });
+ * // Creates builder/ with variables.yaml, env.template, rbac.yaml
+ */
+/**
+ * Validates app name and initial setup
+ * @function validateAppNameAndSetup
+ * @param {string} appName - Application name
+ * @param {Object} options - Options
+ * @returns {Object} Initial paths and type
+ */
+function validateAppNameAndSetup(appName, options) {
+  if (!appName || typeof appName !== 'string') {
+    throw new Error('Application name is required');
+  }
+
+  const initialType = options.type || 'webapp';
+  const baseDir = getBaseDirForAppType(initialType);
+  const appPath = getAppPath(appName, initialType);
+
+  return { initialType, baseDir, appPath };
+}
+
+/**
+ * Handles template validation and loading
+ * @async
+ * @function handleTemplateSetup
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Merged options with template variables
+ */
+async function handleTemplateSetup(options) {
+  if (options.template) {
+    await validateTemplate(options.template);
+  }
+  const templateVariables = await loadTemplateVariables(options.template);
+  return mergeTemplateVariables(options, templateVariables);
+}
+
+/**
+ * Validates and prepares final app path
+ * @async
+ * @function prepareFinalAppPath
+ * @param {string} appName - Application name
+ * @param {Object} config - Configuration
+ * @param {string} initialAppPath - Initial app path
+ * @returns {Promise<string>} Final app path
+ */
+async function prepareFinalAppPath(appName, config, initialAppPath) {
+  const finalBaseDir = getBaseDirForAppType(config.type);
+  const finalAppPath = getAppPath(appName, config.type);
+
+  // If path changed, validate the new path
+  if (finalAppPath !== initialAppPath) {
+    await validateAppDirectoryNotExists(finalAppPath, appName, finalBaseDir);
+  }
+
+  return finalAppPath;
+}
+
+/**
+ * Generates all application files
+ * @async
+ * @function generateApplicationFiles
+ * @param {string} finalAppPath - Final app path
+ * @param {string} appName - Application name
+ * @param {Object} config - Configuration
+ * @param {Object} options - Options
+ * @returns {Promise<string>} Environment conversion message
+ */
+async function generateApplicationFiles(finalAppPath, appName, config, options) {
+  await fs.mkdir(finalAppPath, { recursive: true });
+  await processTemplateFiles(options.template, finalAppPath, appName, options, config);
+
+  const existingEnv = await readExistingEnv(process.cwd());
+  const envConversionMessage = existingEnv
+    ? '\n✓ Found existing .env file - sensitive values will be converted to kv:// references'
+    : '';
+
+  await generateConfigFiles(finalAppPath, appName, config, existingEnv);
+
+  // Generate external system files if type is external
+  if (config.type === 'external') {
+    const externalGenerator = require('../external-system/generator');
+    await externalGenerator.generateExternalSystemFiles(finalAppPath, appName, config);
+  }
+
+  if (options.app) {
+    await setupAppFiles(appName, finalAppPath, config, options);
+  }
+
+  await handleGitHubWorkflows(options, config);
+  return envConversionMessage;
+}
+
+/**
+ * Logs application creation for audit
+ * @async
+ * @function logApplicationCreation
+ * @param {string} appName - Application name
+ * @param {Object} config - Configuration
+ * @param {Object} options - Options
+ */
+async function logApplicationCreation(appName, config, options) {
+  await auditLogger.logApplicationCreation(appName, {
+    language: config.language,
+    port: config.port,
+    database: config.database,
+    redis: config.redis,
+    storage: config.storage,
+    authentication: config.authentication,
+    template: options.template,
+    api: null // Local operation, no API involved
+  });
+}
+
+async function createApp(appName, options = {}) {
+  try {
+    const { appPath } = validateAppNameAndSetup(appName, options);
+    await validateAppCreation(appName, options, appPath, getBaseDirForAppType(options.type || 'webapp'));
+
+    const mergedOptions = await handleTemplateSetup(options);
+    const config = await promptForOptions(appName, mergedOptions);
+
+    const finalAppPath = await prepareFinalAppPath(appName, config, appPath);
+    const envConversionMessage = await generateApplicationFiles(finalAppPath, appName, config, options);
+
+    displaySuccessMessage(appName, config, envConversionMessage, options.app, finalAppPath);
+    await logApplicationCreation(appName, config, options);
+  } catch (error) {
+    throw new Error(`Failed to create application: ${error.message}`);
+  }
+}
+
+/**
+ * Builds a container image for the specified application
+ * Auto-detects runtime and generates Dockerfile if needed
+ *
+ * @async
+ * @function buildApp
+ * @param {string} appName - Name of the application to build
+ * @param {Object} options - Build options
+ * @param {string} [options.language] - Override language detection
+ * @param {boolean} [options.forceTemplate] - Force rebuild from template
+ * @param {string} [options.tag] - Image tag (default: latest)
+ * @returns {Promise<string>} Image tag that was built
+ * @throws {Error} If build fails or app configuration is invalid
+ *
+ * @example
+ * const imageTag = await buildApp('myapp', { language: 'typescript' });
+ * // Returns: 'myapp:latest'
+ */
+async function buildApp(appName, options = {}) {
+  return build.buildApp(appName, options);
+}
+
+/**
+ * Detects the runtime language of an application
+ * Analyzes project files to determine TypeScript, Python, etc.
+ *
+ * @function detectLanguage
+ * @param {string} appPath - Path to application directory
+ * @returns {string} Detected language ('typescript', 'python', etc.)
+ * @throws {Error} If language cannot be detected
+ *
+ * @example
+ * const language = detectLanguage('./myapp');
+ * // Returns: 'typescript'
+ */
+function detectLanguage(appPath) {
+  return build.detectLanguage(appPath);
+}
+
+/**
+ * Generates a Dockerfile from template based on detected language
+ * Uses Handlebars templates to create optimized Dockerfiles
+ *
+ * @async
+ * @function generateDockerfile
+ * @param {string} appPath - Path to application directory
+ * @param {string} language - Target language ('typescript', 'python')
+ * @param {Object} config - Application configuration from variables.yaml
+ * @returns {Promise<string>} Path to generated Dockerfile
+ * @throws {Error} If template generation fails
+ *
+ * @example
+ * const dockerfilePath = await generateDockerfile('./myapp', 'typescript', config);
+ * // Returns: './myapp/.aifabrix/Dockerfile.typescript'
+ */
+async function generateDockerfile(appPath, language, config) {
+  return build.generateDockerfile(appPath, language, config);
+}
+
+/**
+ * Runs the application locally using Docker
+ * Starts container with proper port mapping and environment
+ *
+ * @async
+ * @function runApp
+ * @param {string} appName - Name of the application to run
+ * @param {Object} options - Run options
+ * @param {number} [options.port] - Override local port
+ * @param {boolean} [options.debug] - Enable debug output
+ * @returns {Promise<void>} Resolves when app is running
+ * @throws {Error} If run fails or app is not built
+ *
+ * @example
+ * await runApp('myapp', { port: 3001 });
+ * // Application is now running on localhost:3001
+ */
+async function runApp(appName, options = {}) {
+  return appRun.runApp(appName, options);
+}
+
+/**
+ * Deploys application to controller
+ * @async
+ * @function deployApp
+ * @param {string} appName - Name of the application
+ * @param {Object} options - Deployment options
+ * @returns {Promise<void>} Resolves when deployment is complete
+ */
+async function deployApp(appName, options = {}) {
+  const appDeploy = require('./deploy');
+  return appDeploy.deployApp(appName, options);
+}
+
+module.exports = {
+  createApp,
+  buildApp,
+  runApp,
+  downApp,
+  detectLanguage,
+  generateDockerfile,
+  generateDockerfileForApp,
+  pushApp,
+  deployApp,
+  loadTemplateVariables,
+  updateTemplateVariables,
+  mergeTemplateVariables,
+  checkImageExists: appRun.checkImageExists,
+  checkContainerRunning: appRun.checkContainerRunning,
+  stopAndRemoveContainer: appRun.stopAndRemoveContainer,
+  checkPortAvailable: appRun.checkPortAvailable,
+  generateDockerCompose: appRun.generateDockerCompose,
+  waitForHealthCheck: appRun.waitForHealthCheck
+};

package/lib/{app-list.js → app/list.js}

@@ -9,12 +9,12 @@
  */
 
 const chalk = require('chalk');
-const { getConfig, normalizeControllerUrl } = require('./config');
-const { getOrRefreshDeviceToken } = require('./utils/token-manager');
-const { listEnvironmentApplications } = require('./api/environments.api');
-const { formatApiError } = require('./utils/api-error-handler');
-const { formatAuthenticationError } = require('./utils/error-formatters/http-status-errors');
-const logger = require('./utils/logger');
+const { getConfig, normalizeControllerUrl } = require('../core/config');
+const { getOrRefreshDeviceToken } = require('../utils/token-manager');
+const { listEnvironmentApplications } = require('../api/environments.api');
+const { formatApiError } = require('../utils/api-error-handler');
+const { formatAuthenticationError } = require('../utils/error-formatters/http-status-errors');
+const logger = require('../utils/logger');
 
 /**
  * Extract wrapped array format: { success: true, data: { success: true, data: [...] } }

package/lib/{app-push.js → app/push.js}

@@ -12,8 +12,8 @@ const fs = require('fs').promises;
 const path = require('path');
 const chalk = require('chalk');
 const yaml = require('js-yaml');
-const pushUtils = require('./push');
-const logger = require('./utils/logger');
+const pushUtils = require('../deployment/push');
+const logger = require('../utils/logger');
 
 /**
  * Validate application name format
@@ -70,7 +70,7 @@ function extractImageName(config, appName) {
  */
 async function loadPushConfig(appName, options) {
   // Detect app type and get correct path (integration or builder)
-  const { detectAppType } = require('./utils/paths');
+  const { detectAppType } = require('../utils/paths');
   const { appPath } = await detectAppType(appName);
   const configPath = path.join(appPath, 'variables.yaml');
   try {
@@ -183,7 +183,7 @@ function displayPushResults(registry, imageName, tags) {
  */
 async function pushApp(appName, options = {}) {
   // Check if app type is external - skip push
-  const { detectAppType } = require('./utils/paths');
+  const { detectAppType } = require('../utils/paths');
   try {
     const { isExternal } = await detectAppType(appName);
     if (isExternal) {

package/lib/{app-readme.js → app/readme.js}

@@ -48,7 +48,7 @@ function formatAppDisplayName(appName) {
  */
 function _loadReadmeTemplate() {
   // Use getProjectRoot to reliably find templates in all environments
-  const { getProjectRoot } = require('./utils/paths');
+  const { getProjectRoot } = require('../utils/paths');
   const projectRoot = getProjectRoot();
   const templatePath = path.join(projectRoot, 'templates', 'applications', 'README.md.hbs');
 
@@ -71,32 +71,51 @@ function _loadReadmeTemplate() {
  * @param {Object} config - Application configuration
  * @returns {string} README.md content
  */
-function generateReadmeMd(appName, config) {
+/**
+ * Extracts service flags from config
+ * @function extractServiceFlags
+ * @param {Object} config - Application configuration
+ * @returns {Object} Service flags object
+ */
+function extractServiceFlags(config) {
+  return {
+    hasDatabase: config.database || config.requires?.database || false,
+    hasRedis: config.redis || config.requires?.redis || false,
+    hasStorage: config.storage || config.requires?.storage || false,
+    hasAuthentication: config.authentication || false
+  };
+}
+
+/**
+ * Builds template context for README generation
+ * @function buildReadmeContext
+ * @param {string} appName - Application name
+ * @param {Object} config - Application configuration
+ * @returns {Object} Template context
+ */
+function buildReadmeContext(appName, config) {
   const displayName = formatAppDisplayName(appName);
   const imageName = `aifabrix/${appName}`;
   const port = config.port || 3000;
   // Extract registry from nested structure (config.image.registry) or flattened (config.registry)
   const registry = config.image?.registry || config.registry || 'myacr.azurecr.io';
 
-  const hasDatabase = config.database || config.requires?.database || false;
-  const hasRedis = config.redis || config.requires?.redis || false;
-  const hasStorage = config.storage || config.requires?.storage || false;
-  const hasAuthentication = config.authentication || false;
-  const hasAnyService = hasDatabase || hasRedis || hasStorage || hasAuthentication;
+  const serviceFlags = extractServiceFlags(config);
+  const hasAnyService = serviceFlags.hasDatabase || serviceFlags.hasRedis || serviceFlags.hasStorage || serviceFlags.hasAuthentication;
 
-  const context = {
+  return {
     appName,
     displayName,
     imageName,
     port,
     registry,
-    hasDatabase,
-    hasRedis,
-    hasStorage,
-    hasAuthentication,
+    ...serviceFlags,
     hasAnyService
   };
+}
 
+function generateReadmeMd(appName, config) {
+  const context = buildReadmeContext(appName, config);
   // Always generate comprehensive README programmatically to ensure consistency
   // regardless of template file content
   return generateComprehensiveReadme(context);
@@ -220,10 +239,12 @@ For more information, see the [AI Fabrix Builder documentation](https://docs.aif
  * @throws {Error} If file generation fails
  */
 async function generateReadmeMdFile(appPath, appName, config) {
+  // Ensure directory exists
+  await fs.mkdir(appPath, { recursive: true });
   const readmePath = path.join(appPath, 'README.md');
   if (!(await fileExists(readmePath))) {
     const readmeContent = generateReadmeMd(appName, config);
-    await fs.writeFile(readmePath, readmeContent);
+    await fs.writeFile(readmePath, readmeContent, 'utf8');
   }
 }
 

package/lib/{app-register.js → app/register.js}

@@ -9,19 +9,19 @@
  */
 
 const chalk = require('chalk');
-const logger = require('./utils/logger');
-const { saveLocalSecret, isLocalhost } = require('./utils/local-secrets');
-const { updateEnvTemplate } = require('./utils/env-template');
-const { generateEnvFile } = require('./secrets');
-const { registerApplicationSchema, validateAppRegistrationData } = require('./utils/app-register-validator');
+const logger = require('../utils/logger');
+const { saveLocalSecret, isLocalhost } = require('../utils/local-secrets');
+const { updateEnvTemplate } = require('../utils/env-template');
+const { generateEnvFile } = require('../core/secrets');
+const { registerApplicationSchema, validateAppRegistrationData } = require('../utils/app-register-validator');
 const {
   loadVariablesYaml,
   createMinimalAppIfNeeded,
   extractAppConfiguration
-} = require('./utils/app-register-config');
-const { checkAuthentication } = require('./utils/app-register-auth');
-const { callRegisterApi } = require('./utils/app-register-api');
-const { displayRegistrationResults, getEnvironmentPrefix } = require('./utils/app-register-display');
+} = require('../utils/app-register-config');
+const { checkAuthentication } = require('../utils/app-register-auth');
+const { callRegisterApi } = require('../utils/app-register-api');
+const { displayRegistrationResults, getEnvironmentPrefix } = require('../utils/app-register-display');
 
 /**
  * Build registration data payload from app configuration

package/lib/{app-rotate-secret.js → app/rotate-secret.js}

@@ -9,16 +9,16 @@
  */
 
 const chalk = require('chalk');
-const { getConfig, normalizeControllerUrl } = require('./config');
-const { getOrRefreshDeviceToken } = require('./utils/token-manager');
-const { rotateApplicationSecret } = require('./api/applications.api');
-const { formatApiError } = require('./utils/api-error-handler');
-const { formatAuthenticationError } = require('./utils/error-formatters/http-status-errors');
-const logger = require('./utils/logger');
-const { saveLocalSecret, isLocalhost } = require('./utils/local-secrets');
-const { updateEnvTemplate } = require('./utils/env-template');
-const { getEnvironmentPrefix } = require('./app-register');
-const { generateEnvFile } = require('./secrets');
+const { getConfig, normalizeControllerUrl } = require('../core/config');
+const { getOrRefreshDeviceToken } = require('../utils/token-manager');
+const { rotateApplicationSecret } = require('../api/applications.api');
+const { formatApiError } = require('../utils/api-error-handler');
+const { formatAuthenticationError } = require('../utils/error-formatters/http-status-errors');
+const logger = require('../utils/logger');
+const { saveLocalSecret, isLocalhost } = require('../utils/local-secrets');
+const { updateEnvTemplate } = require('../utils/env-template');
+const { getEnvironmentPrefix } = require('./register');
+const { generateEnvFile } = require('../core/secrets');
 
 /**
  * Find device token from config by trying each stored URL

package/lib/{app-run-helpers.js → app/run-helpers.js}

@@ -16,16 +16,16 @@ const chalk = require('chalk');
 const yaml = require('js-yaml');
 const { exec } = require('child_process');
 const { promisify } = require('util');
-const validator = require('./validator');
-const infra = require('./infra');
-const secrets = require('./secrets');
-const config = require('./config');
-const buildCopy = require('./utils/build-copy');
-const logger = require('./utils/logger');
-const { waitForHealthCheck } = require('./utils/health-check');
-const composeGenerator = require('./utils/compose-generator');
-const dockerUtils = require('./utils/docker');
-const containerHelpers = require('./utils/app-run-containers');
+const validator = require('../validation/validator');
+const infra = require('../infrastructure');
+const secrets = require('../core/secrets');
+const config = require('../core/config');
+const buildCopy = require('../utils/build-copy');
+const logger = require('../utils/logger');
+const { waitForHealthCheck } = require('../utils/health-check');
+const composeGenerator = require('../utils/compose-generator');
+const dockerUtils = require('../utils/docker');
+const containerHelpers = require('../utils/app-run-containers');
 
 const execAsync = promisify(exec);
 

package/lib/{app-run.js → app/run.js}

@@ -10,12 +10,12 @@
  */
 
 const chalk = require('chalk');
-const config = require('./config');
-const logger = require('./utils/logger');
-const { checkPortAvailable, waitForHealthCheck } = require('./utils/health-check');
-const composeGenerator = require('./utils/compose-generator');
+const config = require('../core/config');
+const logger = require('../utils/logger');
+const { checkPortAvailable, waitForHealthCheck } = require('../utils/health-check');
+const composeGenerator = require('../utils/compose-generator');
 // Helper functions extracted to reduce file size and complexity
-const helpers = require('./app-run-helpers');
+const helpers = require('./run-helpers');
 
 /**
  * Validate app for run and check if it's an external system
@@ -31,7 +31,7 @@ async function validateAppForRun(appName, _debug) {
   }
 
   // Check if app type is external - skip Docker run
-  const { detectAppType } = require('./utils/paths');
+  const { detectAppType } = require('../utils/paths');
   try {
     const { isExternal } = await detectAppType(appName);
     if (isExternal) {

package/lib/{build.js → build/index.js}

@@ -13,18 +13,18 @@
 const fs = require('fs').promises;
 const fsSync = require('fs');
 const path = require('path');
-const paths = require('./utils/paths');
-const { detectAppType, getProjectRoot } = require('./utils/paths');
+const paths = require('../utils/paths');
+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 dockerfileUtils = require('./utils/dockerfile-utils');
-const dockerBuild = require('./utils/docker-build');
-const buildCopy = require('./utils/build-copy');
-const { buildDevImageName } = require('./utils/image-name');
-const buildHelpers = require('./utils/build-helpers');
+const secrets = require('../core/secrets');
+const config = require('../core/config');
+const logger = require('../utils/logger');
+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 buildHelpers = require('../utils/build-helpers');
 
 /**
  * Loads variables.yaml configuration for an application
@@ -208,7 +208,7 @@ async function postBuildTasks(appName, buildConfig) {
 async function checkExternalAppType(appName) {
   const variables = await loadVariablesYaml(appName);
   if (variables.app && variables.app.type === 'external') {
-    const generator = require('./generator');
+    const generator = require('../generator');
     const jsonPath = await generator.generateDeployJson(appName);
     logger.log(chalk.green(`✓ Generated deployment JSON: ${jsonPath}`));
     return true;
@@ -224,6 +224,51 @@ async function checkExternalAppType(appName) {
  * @param {Object} options - Build options
  * @returns {Promise<Object>} Object with devDir, effectiveImageName, imageName, appConfig, and developerId
  */
+/**
+ * Copies application source files if they exist
+ * @async
+ * @function copyApplicationSourceFiles
+ * @param {string} appName - Application name
+ * @param {string} devDir - Developer directory
+ * @returns {Promise<boolean>} True if files were copied
+ */
+async function copyApplicationSourceFiles(appName, devDir) {
+  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}`));
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Copies template files if needed
+ * @async
+ * @function copyTemplateFilesIfNeeded
+ * @param {string} devDir - Developer directory
+ * @param {string} language - Language type
+ * @param {Object} buildConfig - Build configuration
+ * @param {Object} options - Build options
+ */
+async function copyTemplateFilesIfNeeded(devDir, language, buildConfig, options) {
+  const detectedLanguage = options.language || buildConfig.language || detectLanguage(devDir);
+  const packageJsonPath = path.join(devDir, 'package.json');
+  const requirementsPath = path.join(devDir, 'requirements.txt');
+
+  if (detectedLanguage === 'typescript' && !fsSync.existsSync(packageJsonPath)) {
+    const projectRoot = getProjectRoot();
+    const templatePath = path.join(projectRoot, 'templates', 'typescript');
+    await buildCopy.copyTemplateFilesToDevDir(templatePath, devDir, detectedLanguage);
+    logger.log(chalk.green(`✓ Generated application files from ${detectedLanguage} template`));
+  } else if (detectedLanguage === 'python' && !fsSync.existsSync(requirementsPath)) {
+    const projectRoot = getProjectRoot();
+    const templatePath = path.join(projectRoot, 'templates', 'python');
+    await buildCopy.copyTemplateFilesToDevDir(templatePath, devDir, detectedLanguage);
+    logger.log(chalk.green(`✓ Generated application files from ${detectedLanguage} template`));
+  }
+}
+
 async function prepareDevDirectory(appName, buildConfig, options) {
   const developerId = await config.getDeveloperId();
   const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
@@ -236,27 +281,9 @@ async function prepareDevDirectory(appName, buildConfig, options) {
   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`));
-    }
+  const filesCopied = await copyApplicationSourceFiles(appName, devDir);
+  if (!filesCopied) {
+    await copyTemplateFilesIfNeeded(devDir, null, buildConfig, options);
   }
 
   return { devDir, effectiveImageName, imageName, appConfig };