@aifabrix/builder 2.7.0 → 2.9.0

package/lib/app-prompts.js

@@ -13,11 +13,17 @@ const inquirer = require('inquirer');
 /**
  * Builds basic questions (port, language)
  * @param {Object} options - Provided options
+ * @param {string} [appType] - Application type (webapp, api, service, functionapp, external)
  * @returns {Array} Array of question objects
  */
-function buildBasicQuestions(options) {
+function buildBasicQuestions(options, appType) {
   const questions = [];
 
+  // Skip port and language for external type
+  if (appType === 'external') {
+    return questions;
+  }
+
   // Port validation
   if (!options.port) {
     questions.push({
@@ -55,11 +61,17 @@ function buildBasicQuestions(options) {
 /**
  * Builds service questions (database, redis, storage, authentication)
  * @param {Object} options - Provided options
+ * @param {string} [appType] - Application type (webapp, api, service, functionapp, external)
  * @returns {Array} Array of question objects
  */
-function buildServiceQuestions(options) {
+function buildServiceQuestions(options, appType) {
   const questions = [];
 
+  // Skip service questions for external type
+  if (appType === 'external') {
+    return questions;
+  }
+
   if (!Object.prototype.hasOwnProperty.call(options, 'database')) {
     questions.push({
       type: 'confirm',
@@ -99,6 +111,116 @@ function buildServiceQuestions(options) {
   return questions;
 }
 
+/**
+ * Builds external system configuration questions
+ * @param {Object} options - Provided options
+ * @param {string} appName - Application name
+ * @returns {Array} Array of question objects
+ */
+function buildExternalSystemQuestions(options, appName) {
+  const questions = [];
+
+  // System key (defaults to app name)
+  if (!options.systemKey) {
+    questions.push({
+      type: 'input',
+      name: 'systemKey',
+      message: 'What is the system key?',
+      default: appName,
+      validate: (input) => {
+        if (!input || input.trim().length === 0) {
+          return 'System key is required';
+        }
+        if (!/^[a-z0-9-]+$/.test(input)) {
+          return 'System key must contain only lowercase letters, numbers, and hyphens';
+        }
+        return true;
+      }
+    });
+  }
+
+  // System display name
+  if (!options.systemDisplayName) {
+    questions.push({
+      type: 'input',
+      name: 'systemDisplayName',
+      message: 'What is the system display name?',
+      default: appName.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase()),
+      validate: (input) => {
+        if (!input || input.trim().length === 0) {
+          return 'System display name is required';
+        }
+        return true;
+      }
+    });
+  }
+
+  // System description
+  if (!options.systemDescription) {
+    questions.push({
+      type: 'input',
+      name: 'systemDescription',
+      message: 'What is the system description?',
+      default: `External system integration for ${appName}`,
+      validate: (input) => {
+        if (!input || input.trim().length === 0) {
+          return 'System description is required';
+        }
+        return true;
+      }
+    });
+  }
+
+  // System type
+  if (!options.systemType) {
+    questions.push({
+      type: 'list',
+      name: 'systemType',
+      message: 'What is the system type?',
+      choices: [
+        { name: 'OpenAPI', value: 'openapi' },
+        { name: 'MCP (Model Context Protocol)', value: 'mcp' },
+        { name: 'Custom', value: 'custom' }
+      ],
+      default: 'openapi'
+    });
+  }
+
+  // Authentication type
+  if (!options.authType) {
+    questions.push({
+      type: 'list',
+      name: 'authType',
+      message: 'What authentication type does the system use?',
+      choices: [
+        { name: 'OAuth2', value: 'oauth2' },
+        { name: 'API Key', value: 'apikey' },
+        { name: 'Basic Auth', value: 'basic' }
+      ],
+      default: 'apikey'
+    });
+  }
+
+  // Number of datasources
+  if (!options.datasourceCount) {
+    questions.push({
+      type: 'input',
+      name: 'datasourceCount',
+      message: 'How many datasources do you want to create?',
+      default: '1',
+      validate: (input) => {
+        const count = parseInt(input, 10);
+        if (isNaN(count) || count < 1 || count > 10) {
+          return 'Datasource count must be a number between 1 and 10';
+        }
+        return true;
+      }
+    });
+  }
+
+  return questions;
+}
+
 /**
  * Builds workflow questions (GitHub, Controller)
  * @param {Object} options - Provided options
@@ -186,7 +308,7 @@ function resolveOptionalBoolean(optionValue, answerValue, defaultValue) {
  * @returns {Object} Resolved configuration
  */
 function resolveConflicts(options, answers) {
-  return {
+  const config = {
     port: parseInt(resolveField(options.port, answers.port, 3000), 10),
     language: resolveField(options.language, answers.language, 'typescript'),
     database: resolveField(options.database, answers.database, false),
@@ -197,6 +319,28 @@ function resolveConflicts(options, answers) {
     controller: resolveOptionalBoolean(options.controller, answers.controller, false),
     controllerUrl: resolveField(options.controllerUrl, answers.controllerUrl, undefined)
   };
+
+  // Add external system fields if present
+  if (answers.systemKey || options.systemKey) {
+    config.systemKey = resolveField(options.systemKey, answers.systemKey, undefined);
+  }
+  if (answers.systemDisplayName || options.systemDisplayName) {
+    config.systemDisplayName = resolveField(options.systemDisplayName, answers.systemDisplayName, undefined);
+  }
+  if (answers.systemDescription || options.systemDescription) {
+    config.systemDescription = resolveField(options.systemDescription, answers.systemDescription, undefined);
+  }
+  if (answers.systemType || options.systemType) {
+    config.systemType = resolveField(options.systemType, answers.systemType, 'openapi');
+  }
+  if (answers.authType || options.authType) {
+    config.authType = resolveField(options.authType, answers.authType, 'apikey');
+  }
+  if (answers.datasourceCount || options.datasourceCount) {
+    config.datasourceCount = parseInt(resolveField(options.datasourceCount, answers.datasourceCount, 1), 10);
+  }
+
+  return config;
 }
 
 /**
@@ -220,22 +364,42 @@ function mergePromptAnswers(appName, options, answers) {
  * @returns {Promise<Object>} Complete configuration
  */
 async function promptForOptions(appName, options) {
-  // Default github to false if not provided (make it truly optional)
-  if (!Object.prototype.hasOwnProperty.call(options, 'github')) {
-    options.github = false;
-  }
+  // Get app type from options (default to webapp)
+  const appType = options.type || 'webapp';
 
-  const questions = [
-    ...buildBasicQuestions(options),
-    ...buildServiceQuestions(options),
-    ...buildWorkflowQuestions(options)
-  ];
+  // Build questions based on app type
+  let questions = [];
+  if (appType === 'external') {
+    // For external type, prompt for external system configuration
+    questions = [
+      ...buildExternalSystemQuestions(options, appName),
+      ...buildWorkflowQuestions(options)
+    ];
+  } else {
+    // For regular apps, use standard prompts
+    questions = [
+      ...buildBasicQuestions(options, appType),
+      ...buildServiceQuestions(options, appType),
+      ...buildWorkflowQuestions(options)
+    ];
+  }
 
   // Prompt for missing options
   const answers = questions.length > 0 ? await inquirer.prompt(questions) : {};
 
   // Merge provided options with answers
-  return mergePromptAnswers(appName, options, answers);
+  const merged = mergePromptAnswers(appName, options, answers);
+
+  // Add type to merged config
+  merged.type = appType;
+
+  // For external type, remove port and language as they're not applicable
+  if (appType === 'external') {
+    delete merged.port;
+    delete merged.language;
+  }
+
+  return merged;
 }
 
 module.exports = {

package/lib/app-push.js

@@ -69,7 +69,10 @@ function extractImageName(config, appName) {
  * @throws {Error} If configuration cannot be loaded
  */
 async function loadPushConfig(appName, options) {
-  const configPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
+  // Detect app type and get correct path (integration or builder)
+  const { detectAppType } = require('./utils/paths');
+  const { appPath } = await detectAppType(appName);
+  const configPath = path.join(appPath, 'variables.yaml');
   try {
     const config = yaml.load(await fs.readFile(configPath, 'utf8'));
     const registry = options.registry || config.image?.registry;
@@ -179,6 +182,18 @@ function displayPushResults(registry, imageName, tags) {
  * @returns {Promise<void>} Resolves when push is complete
  */
 async function pushApp(appName, options = {}) {
+  // Check if app type is external - skip push
+  const { detectAppType } = require('./utils/paths');
+  try {
+    const { isExternal } = await detectAppType(appName);
+    if (isExternal) {
+      logger.log(chalk.yellow('⚠️  External systems don\'t require Docker images. Skipping push...'));
+      return;
+    }
+  } catch (error) {
+    // If detection fails, continue with normal push
+    // (detectAppType throws if app doesn't exist, which is fine for push command)
+  }
   try {
     // Validate app name
     validateAppName(appName);

package/lib/app-register.js

@@ -19,6 +19,8 @@ const logger = require('./utils/logger');
 const { saveLocalSecret, isLocalhost } = require('./utils/local-secrets');
 const { updateEnvTemplate } = require('./utils/env-template');
 const { getOrRefreshDeviceToken } = require('./utils/token-manager');
+const { detectAppType } = require('./utils/paths');
+const { generateEnvFile } = require('./secrets');
 
 // Import createApp to auto-generate config if missing
 let createApp;
@@ -86,7 +88,9 @@ const registerApplicationSchema = {
  * @returns {Promise<{variables: Object, created: boolean}>} Variables and creation flag
  */
 async function loadVariablesYaml(appKey) {
-  const variablesPath = path.join(process.cwd(), 'builder', appKey, 'variables.yaml');
+  // Detect app type and get correct path (integration or builder)
+  const { appPath } = await detectAppType(appKey);
+  const variablesPath = path.join(appPath, 'variables.yaml');
 
   try {
     const variablesContent = await fs.readFile(variablesPath, 'utf-8');
@@ -122,7 +126,9 @@ async function createMinimalAppIfNeeded(appKey, options) {
     authentication: false
   });
 
-  const variablesPath = path.join(process.cwd(), 'builder', appKey, 'variables.yaml');
+  // Detect app type and get correct path (integration or builder)
+  const { appPath } = await detectAppType(appKey);
+  const variablesPath = path.join(appPath, 'variables.yaml');
   const variablesContent = await fs.readFile(variablesPath, 'utf-8');
   return yaml.load(variablesContent);
 }
@@ -138,6 +144,20 @@ function extractAppConfiguration(variables, appKey, options) {
   const appKeyFromFile = variables.app?.key || appKey;
   const displayName = variables.app?.name || options.name || appKey;
   const description = variables.app?.description || '';
+
+  // Handle external type
+  if (variables.app?.type === 'external') {
+    return {
+      appKey: appKeyFromFile,
+      displayName,
+      description,
+      appType: 'external',
+      registryMode: 'external',
+      port: null, // External systems don't need ports
+      language: null // External systems don't need language
+    };
+  }
+
   const appType = variables.build?.language === 'typescript' ? 'webapp' : 'service';
   const registryMode = 'external';
   const port = variables.build?.port || options.port || 3000;
@@ -156,11 +176,12 @@ function extractAppConfiguration(variables, appKey, options) {
 
 /**
  * Validate application registration data
+ * @async
  * @param {Object} config - Application configuration
  * @param {string} originalAppKey - Original app key for error messages
  * @throws {Error} If validation fails
  */
-function validateAppRegistrationData(config, originalAppKey) {
+async function validateAppRegistrationData(config, originalAppKey) {
   const missingFields = [];
   if (!config.appKey) missingFields.push('app.key');
   if (!config.displayName) missingFields.push('app.name');
@@ -168,7 +189,10 @@ function validateAppRegistrationData(config, originalAppKey) {
   if (missingFields.length > 0) {
     logger.error(chalk.red('❌ Missing required fields in variables.yaml:'));
     missingFields.forEach(field => logger.error(chalk.red(`   - ${field}`)));
-    logger.error(chalk.red(`\n   Please update builder/${originalAppKey}/variables.yaml and try again.`));
+    // Detect app type to show correct path
+    const { appPath } = await detectAppType(originalAppKey);
+    const relativePath = path.relative(process.cwd(), appPath);
+    logger.error(chalk.red(`\n   Please update ${relativePath}/variables.yaml and try again.`));
     process.exit(1);
   }
 
@@ -368,7 +392,7 @@ async function registerApplication(appKey, options) {
   const appConfig = extractAppConfiguration(finalVariables, appKey, options);
 
   // Validate configuration (pass original appKey for error messages)
-  validateAppRegistrationData(appConfig, appKey);
+  await validateAppRegistrationData(appConfig, appKey);
 
   // Get controller URL from variables.yaml if available
   const controllerUrl = finalVariables?.deployment?.controllerUrl;
@@ -420,6 +444,14 @@ async function registerApplication(appKey, options) {
       // Update env.template
       await updateEnvTemplate(registeredAppKey, clientIdKey, clientSecretKey, authConfig.apiUrl);
 
+      // Regenerate .env file with updated credentials
+      try {
+        await generateEnvFile(registeredAppKey, null, 'local');
+        logger.log(chalk.green('✓ .env file updated with new credentials'));
+      } catch (error) {
+        logger.warn(chalk.yellow(`⚠️  Could not regenerate .env file: ${error.message}`));
+      }
+
       logger.log(chalk.green('\n✓ Credentials saved to ~/.aifabrix/secrets.local.yaml'));
       logger.log(chalk.green('✓ env.template updated with MISO_CLIENTID, MISO_CLIENTSECRET, and MISO_CONTROLLER_URL\n'));
     } catch (error) {

package/lib/app-rotate-secret.js

@@ -17,6 +17,7 @@ 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');
 
 /**
  * Validate environment parameter
@@ -147,6 +148,15 @@ async function rotateSecret(appKey, options) {
     // Update env.template if localhost
     if (isLocalhost(controllerUrl)) {
       await updateEnvTemplate(appKey, clientIdKey, clientSecretKey, controllerUrl);
+
+      // Regenerate .env file with updated credentials
+      try {
+        await generateEnvFile(appKey, null, 'local');
+        logger.log(chalk.green('✓ .env file updated with new credentials'));
+      } catch (error) {
+        logger.warn(chalk.yellow(`⚠️  Could not regenerate .env file: ${error.message}`));
+      }
+
       logger.log(chalk.green('\n✓ Credentials saved to ~/.aifabrix/secrets.local.yaml'));
       logger.log(chalk.green('✓ env.template updated with MISO_CLIENTID, MISO_CLIENTSECRET, and MISO_CONTROLLER_URL\n'));
     } else {

package/lib/app-run.js

@@ -43,6 +43,25 @@ async function runApp(appName, options = {}) {
   }
 
   try {
+    // Validate app name first
+    if (!appName || typeof appName !== 'string') {
+      throw new Error('Application name is required');
+    }
+
+    // Check if app type is external - skip Docker run
+    const { detectAppType } = require('./utils/paths');
+    try {
+      const { isExternal } = await detectAppType(appName);
+      if (isExternal) {
+        logger.log(chalk.yellow('⚠️  External systems don\'t run as Docker containers.'));
+        logger.log(chalk.blue('Use "aifabrix build" to deploy to dataplane, then test via OpenAPI endpoints.'));
+        return;
+      }
+    } catch (error) {
+      // If detection fails, continue with normal run
+      // (detectAppType throws if app doesn't exist, which is fine for run command)
+    }
+
     // Validate app name and load configuration
     const appConfig = await helpers.validateAppConfiguration(appName);
 

package/lib/app.js

@@ -24,6 +24,7 @@ const { loadTemplateVariables, updateTemplateVariables, mergeTemplateVariables }
 const logger = require('./utils/logger');
 const auditLogger = require('./audit-logger');
 const { downApp } = require('./app-down');
+const { getAppPath } = require('./utils/paths');
 
 /**
  * Displays success message after app creation
@@ -31,27 +32,43 @@ const { downApp } = require('./app-down');
  * @param {Object} config - Final configuration
  * @param {string} envConversionMessage - Environment conversion message
  */
-function displaySuccessMessage(appName, config, envConversionMessage, hasAppFiles = false) {
+function displaySuccessMessage(appName, config, envConversionMessage, hasAppFiles = false, appPath = null) {
   logger.log(chalk.green('\n✓ Application created successfully!'));
   logger.log(chalk.blue(`\nApplication: ${appName}`));
-  logger.log(chalk.blue(`Location: builder/${appName}/`));
+
+  // Determine location based on app type
+  const baseDir = config.type === 'external' ? 'integration' : 'builder';
+  const location = appPath ? path.relative(process.cwd(), appPath) : `${baseDir}/${appName}/`;
+  logger.log(chalk.blue(`Location: ${location}`));
+
   if (hasAppFiles) {
     logger.log(chalk.blue(`Application files: apps/${appName}/`));
   }
-  logger.log(chalk.blue(`Language: ${config.language}`));
-  logger.log(chalk.blue(`Port: ${config.port}`));
-
-  if (config.database) logger.log(chalk.yellow('  - Database enabled'));
-  if (config.redis) logger.log(chalk.yellow('  - Redis enabled'));
-  if (config.storage) logger.log(chalk.yellow('  - Storage enabled'));
-  if (config.authentication) logger.log(chalk.yellow('  - Authentication enabled'));
-
-  logger.log(chalk.gray(envConversionMessage));
 
-  logger.log(chalk.green('\nNext steps:'));
-  logger.log(chalk.white('1. Copy env.template to .env and fill in your values'));
-  logger.log(chalk.white('2. Run: aifabrix build ' + appName));
-  logger.log(chalk.white('3. Run: aifabrix run ' + appName));
+  if (config.type === 'external') {
+    logger.log(chalk.blue('Type: External System'));
+    logger.log(chalk.blue(`System Key: ${config.systemKey || appName}`));
+    logger.log(chalk.green('\nNext steps:'));
+    logger.log(chalk.white('1. Edit external system JSON files in ' + location));
+    logger.log(chalk.white('2. Run: aifabrix app register ' + appName + ' --environment dev'));
+    logger.log(chalk.white('3. Run: aifabrix build ' + appName + ' (deploys to dataplane)'));
+    logger.log(chalk.white('4. Run: aifabrix deploy ' + appName + ' (publishes to dataplane)'));
+  } else {
+    logger.log(chalk.blue(`Language: ${config.language}`));
+    logger.log(chalk.blue(`Port: ${config.port}`));
+
+    if (config.database) logger.log(chalk.yellow('  - Database enabled'));
+    if (config.redis) logger.log(chalk.yellow('  - Redis enabled'));
+    if (config.storage) logger.log(chalk.yellow('  - Storage enabled'));
+    if (config.authentication) logger.log(chalk.yellow('  - Authentication enabled'));
+
+    logger.log(chalk.gray(envConversionMessage));
+
+    logger.log(chalk.green('\nNext steps:'));
+    logger.log(chalk.white('1. Copy env.template to .env and fill in your values'));
+    logger.log(chalk.white('2. Run: aifabrix build ' + appName));
+    logger.log(chalk.white('3. Run: aifabrix run ' + appName));
+  }
 }
 
 /**
@@ -72,6 +89,16 @@ async function validateAppDirectoryNotExists(appPath, appName, baseDir = 'builde
   }
 }
 
+/**
+ * Gets the base directory path for an app based on its type
+ * @param {string} appName - Application name
+ * @param {string} appType - Application type ('external' or other)
+ * @returns {string} Base directory path ('integration' or 'builder')
+ */
+function getBaseDirForAppType(appType) {
+  return appType === 'external' ? 'integration' : 'builder';
+}
+
 /**
  * Handles GitHub workflow generation if requested
  * @async
@@ -113,9 +140,9 @@ async function handleGitHubWorkflows(options, config) {
  * @param {string} appPath - Application directory path
  * @throws {Error} If validation fails
  */
-async function validateAppCreation(appName, options, appPath) {
+async function validateAppCreation(appName, options, appPath, baseDir = 'builder') {
   validateAppName(appName);
-  await validateAppDirectoryNotExists(appPath, appName, 'builder');
+  await validateAppDirectoryNotExists(appPath, appName, baseDir);
 
   if (!options.app) {
     return;
@@ -261,10 +288,13 @@ async function createApp(appName, options = {}) {
       throw new Error('Application name is required');
     }
 
-    const builderPath = path.join(process.cwd(), 'builder');
-    const appPath = path.join(builderPath, appName);
+    // Determine app type from options (will be confirmed during prompts)
+    // For now, check if type is explicitly set in options
+    const initialType = options.type || 'webapp';
+    const baseDir = getBaseDirForAppType(initialType);
+    const appPath = getAppPath(appName, initialType);
 
-    await validateAppCreation(appName, options, appPath);
+    await validateAppCreation(appName, options, appPath, baseDir);
 
     if (options.template) {
       await validateTemplate(options.template);
@@ -274,22 +304,37 @@ async function createApp(appName, options = {}) {
     const mergedOptions = mergeTemplateVariables(options, templateVariables);
     const config = await promptForOptions(appName, mergedOptions);
 
-    await fs.mkdir(appPath, { recursive: true });
-    await processTemplateFiles(options.template, appPath, appName, options, config);
+    // Update appPath based on final config type (may have changed during prompts)
+    const finalBaseDir = getBaseDirForAppType(config.type);
+    const finalAppPath = getAppPath(appName, config.type);
+
+    // If path changed, validate the new path
+    if (finalAppPath !== appPath) {
+      await validateAppDirectoryNotExists(finalAppPath, appName, finalBaseDir);
+    }
+
+    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(appPath, appName, config, existingEnv);
+    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, appPath, config, options);
+      await setupAppFiles(appName, finalAppPath, config, options);
     }
 
     await handleGitHubWorkflows(options, config);
-    displaySuccessMessage(appName, config, envConversionMessage, options.app);
+    displaySuccessMessage(appName, config, envConversionMessage, options.app, finalAppPath);
 
     // Log application creation for audit trail
     await auditLogger.logApplicationCreation(appName, {

package/lib/audit-logger.js

@@ -106,9 +106,14 @@ function createAuditEntry(level, message, metadata = {}) {
   for (const [key, value] of Object.entries(metadata)) {
     // Skip null and undefined values to keep logs clean
     if (value !== null && value !== undefined) {
-      entry.metadata[key] = maskSensitiveData(
-        typeof value === 'string' ? value : JSON.stringify(value)
-      );
+      // Only mask strings; preserve other types (numbers, booleans, etc.)
+      if (typeof value === 'string') {
+        entry.metadata[key] = maskSensitiveData(value);
+      } else {
+        // For non-string values, stringify only if it's an object/array
+        // Preserve primitives (numbers, booleans) as-is
+        entry.metadata[key] = typeof value === 'object' ? JSON.stringify(value) : value;
+      }
     }
   }
 
@@ -280,7 +285,7 @@ async function logApiCall(url, options, statusCode, duration, success, errorInfo
     path,
     url: maskSensitiveData(url),
     controllerUrl: maskSensitiveData(controllerUrl),
-    statusCode,
+    statusCode: Number(statusCode),
     duration,
     success,
     timestamp: Date.now()

package/lib/build.js

@@ -14,6 +14,7 @@ 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 chalk = require('chalk');
@@ -68,9 +69,17 @@ async function copyTemplateFilesToDevDir(templatePath, devDir, _language) {
     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);
+    // 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;
+      }
     }
   }
 }
@@ -82,7 +91,9 @@ async function copyTemplateFilesToDevDir(templatePath, devDir, _language) {
  * @throws {Error} If file cannot be loaded or parsed
  */
 async function loadVariablesYaml(appName) {
-  const variablesPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
+  // Detect app type and get correct path (integration or builder)
+  const { appPath } = await detectAppType(appName);
+  const variablesPath = path.join(appPath, 'variables.yaml');
 
   if (!fsSync.existsSync(variablesPath)) {
     throw new Error(`Configuration not found. Run 'aifabrix create ${appName}' first.`);
@@ -335,6 +346,15 @@ async function postBuildTasks(appName, buildConfig) {
  * // Returns: 'myapp:latest'
  */
 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}`));
+    return null;
+  }
+
   try {
     logger.log(chalk.blue(`\n🔨 Building application: ${appName}`));
 
@@ -474,12 +494,4 @@ async function buildApp(appName, options = {}) {
   }
 }
 
-module.exports = {
-  loadVariablesYaml,
-  resolveContextPath,
-  executeDockerBuild: dockerBuild.executeDockerBuild,
-  detectLanguage,
-  generateDockerfile,
-  buildApp,
-  postBuildTasks
-};
+module.exports = { loadVariablesYaml, resolveContextPath, executeDockerBuild: dockerBuild.executeDockerBuild, detectLanguage, generateDockerfile, buildApp, postBuildTasks };