@aifabrix/builder 2.32.2 → 2.33.0

package/lib/utils/controller-url.js

@@ -0,0 +1,115 @@
+/**
+ * Controller URL Resolution Utilities
+ *
+ * Provides utilities for resolving controller URLs with developer ID-based defaults
+ * and fallback chain support.
+ *
+ * @fileoverview Controller URL resolution utilities
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { getDeveloperIdNumber } = require('./env-map');
+const devConfig = require('./dev-config');
+const config = require('../core/config');
+
+/**
+ * Calculate default controller URL based on developer ID
+ * Uses getDevPorts to get the app port which is adjusted by developer ID
+ * Developer ID 0 = http://localhost:3000
+ * Developer ID 1 = http://localhost:3100
+ * Developer ID 2 = http://localhost:3200
+ * @async
+ * @function getDefaultControllerUrl
+ * @returns {Promise<string>} Default controller URL
+ */
+async function getDefaultControllerUrl() {
+  const developerId = await getDeveloperIdNumber(null);
+  const ports = devConfig.getDevPorts(developerId);
+  return `http://localhost:${ports.app}`;
+}
+
+/**
+ * Normalize controller URL (remove trailing slashes)
+ * @param {string} url - Controller URL to normalize
+ * @returns {string} Normalized controller URL
+ */
+function normalizeUrl(url) {
+  if (!url || typeof url !== 'string') {
+    return url;
+  }
+  return url.trim().replace(/\/+$/, '');
+}
+
+/**
+ * Get controller URL from logged-in user's device tokens
+ * Returns the first available controller URL from device tokens stored in config
+ * @async
+ * @function getControllerUrlFromLoggedInUser
+ * @returns {Promise<string|null>} Controller URL from logged-in user, or null if not found
+ */
+async function getControllerUrlFromLoggedInUser() {
+  try {
+    const userConfig = await config.getConfig();
+    if (!userConfig.device || typeof userConfig.device !== 'object') {
+      return null;
+    }
+
+    const deviceUrls = Object.keys(userConfig.device);
+    if (deviceUrls.length === 0) {
+      return null;
+    }
+
+    // Return the first available controller URL (normalized)
+    const firstControllerUrl = deviceUrls[0];
+    return normalizeUrl(firstControllerUrl);
+  } catch (error) {
+    // If config doesn't exist or can't be read, return null
+    return null;
+  }
+}
+
+/**
+ * Get controller URL from config.yaml
+ * @async
+ * @function getControllerFromConfig
+ * @returns {Promise<string|null>} Controller URL from config or null
+ */
+async function getControllerFromConfig() {
+  const { getControllerUrl } = require('../core/config');
+  return await getControllerUrl();
+}
+
+/**
+ * Resolve controller URL with fallback chain
+ * Priority:
+ * 1. config.controller (from config.yaml)
+ * 2. getControllerUrlFromLoggedInUser() (from logged-in device tokens)
+ * 3. getDefaultControllerUrl() (developer ID-based default)
+ * @async
+ * @function resolveControllerUrl
+ * @returns {Promise<string>} Resolved controller URL
+ */
+async function resolveControllerUrl() {
+  // Priority 1: config.controller (from config.yaml)
+  const configController = await getControllerFromConfig();
+  if (configController) {
+    return configController.replace(/\/+$/, '');
+  }
+
+  // Priority 2: Logged-in user's device tokens
+  const loggedInControllerUrl = await getControllerUrlFromLoggedInUser();
+  if (loggedInControllerUrl) {
+    return loggedInControllerUrl;
+  }
+
+  // Priority 3: Developer ID-based default
+  return await getDefaultControllerUrl();
+}
+
+module.exports = {
+  getDefaultControllerUrl,
+  getControllerUrlFromLoggedInUser,
+  getControllerFromConfig,
+  resolveControllerUrl
+};

package/lib/utils/dataplane-health.js

@@ -0,0 +1,115 @@
+/**
+ * Dataplane Health Check Utilities
+ *
+ * Provides utilities for checking dataplane URL health and reachability
+ *
+ * @fileoverview Dataplane health check utilities
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+/**
+ * Tests a single endpoint for reachability
+ * @async
+ * @function testEndpoint
+ * @param {string} testUrl - URL to test
+ * @param {number} timeoutMs - Timeout in milliseconds
+ * @returns {Promise<boolean>} True if endpoint is reachable
+ */
+async function testEndpoint(testUrl, timeoutMs) {
+  try {
+    const controller = new AbortController();
+    const abortTimeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    let raceTimeoutId;
+
+    const response = await Promise.race([
+      fetch(testUrl, {
+        method: 'GET',
+        signal: controller.signal,
+        headers: { 'Accept': 'application/json' }
+      }),
+      new Promise((_, reject) => {
+        raceTimeoutId = setTimeout(() => reject(new Error('Timeout')), timeoutMs);
+      })
+    ]).catch(() => null);
+
+    clearTimeout(abortTimeoutId);
+    if (raceTimeoutId) {
+      clearTimeout(raceTimeoutId);
+    }
+
+    // If we get any response (even 404 or 401), the service is reachable
+    // 401 is OK because it means the API is working, just needs auth
+    if (response && (response.ok || response.status === 404 || response.status === 401)) {
+      return true;
+    }
+
+    // If we get a 500 or other server error, the service is up but broken
+    // Still consider it "reachable" - the wizard will handle the actual error
+    if (response && response.status >= 500) {
+      return true;
+    }
+
+    // If response is null (timeout/error), endpoint is not reachable
+    return false;
+  } catch (error) {
+    // Timeout or abort means endpoint is not reachable
+    return false;
+  }
+}
+
+/**
+ * Checks if dataplane URL is reachable and API is functional
+ * @async
+ * @function checkDataplaneHealth
+ * @param {string} dataplaneUrl - Dataplane URL to check
+ * @param {number} timeoutMs - Timeout in milliseconds (default: 5000)
+ * @returns {Promise<boolean>} True if dataplane is reachable and functional
+ */
+async function checkDataplaneHealth(dataplaneUrl, timeoutMs = 5000) {
+  if (!dataplaneUrl) {
+    return false;
+  }
+
+  const baseUrl = dataplaneUrl.replace(/\/+$/, '');
+  const endpointsToTest = ['/health', '/api/v1/health', '/api/health', ''];
+
+  for (const endpoint of endpointsToTest) {
+    const testUrl = endpoint ? `${baseUrl}${endpoint}` : baseUrl;
+    const isReachable = await testEndpoint(testUrl, timeoutMs);
+    if (isReachable) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Validates dataplane health before running wizard
+ * @async
+ * @function validateDataplaneHealth
+ * @param {string} dataplaneUrl - Dataplane URL to check
+ * @returns {Promise<Error|null>} Error if unhealthy, null if healthy
+ */
+async function validateDataplaneHealth(dataplaneUrl) {
+  try {
+    const isHealthy = await checkDataplaneHealth(dataplaneUrl, 5000);
+    if (!isHealthy) {
+      return new Error(
+        `Dataplane is not reachable at ${dataplaneUrl}.\n\n` +
+        'Please ensure the dataplane service is running and accessible, then try again.\n' +
+        `You can check dataplane status with: curl ${dataplaneUrl}/health`
+      );
+    }
+    return null;
+  } catch (error) {
+    return new Error(`Failed to check dataplane health: ${error.message}`);
+  }
+}
+
+module.exports = {
+  checkDataplaneHealth,
+  validateDataplaneHealth,
+  testEndpoint
+};

package/lib/utils/dataplane-resolver.js

@@ -0,0 +1,29 @@
+/**
+ * Dataplane URL Resolver
+ *
+ * Resolves dataplane URL by discovering from controller
+ *
+ * @fileoverview Dataplane URL resolution utilities
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { discoverDataplaneUrl } = require('../commands/wizard-dataplane');
+
+/**
+ * Resolve dataplane URL by discovering from controller
+ * @async
+ * @function resolveDataplaneUrl
+ * @param {string} controllerUrl - Controller URL
+ * @param {string} environment - Environment key
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<string>} Resolved dataplane URL
+ * @throws {Error} If dataplane URL cannot be resolved
+ */
+async function resolveDataplaneUrl(controllerUrl, environment, authConfig) {
+  return await discoverDataplaneUrl(controllerUrl, environment, authConfig);
+}
+
+module.exports = {
+  resolveDataplaneUrl
+};

package/lib/utils/dev-config.js

@@ -18,7 +18,9 @@ const BASE_PORTS = {
   postgres: 5432,
   redis: 6379,
   pgadmin: 5050,
-  redisCommander: 8081
+  redisCommander: 8081,
+  traefikHttp: 80,
+  traefikHttps: 443
 };
 
 /**
@@ -65,7 +67,9 @@ function getDevPorts(developerId) {
     postgres: BASE_PORTS.postgres + offset,
     redis: BASE_PORTS.redis + offset,
     pgadmin: BASE_PORTS.pgadmin + offset,
-    redisCommander: BASE_PORTS.redisCommander + offset
+    redisCommander: BASE_PORTS.redisCommander + offset,
+    traefikHttp: BASE_PORTS.traefikHttp + offset,
+    traefikHttps: BASE_PORTS.traefikHttps + offset
   };
 }
 

package/lib/utils/env-copy.js

@@ -18,6 +18,7 @@ const devConfig = require('../utils/dev-config');
 const { rewriteInfraEndpoints } = require('./env-endpoints');
 const { buildEnvVarMap } = require('./env-map');
 const { interpolateEnvVars } = require('./secrets-helpers');
+const { getLocalPort } = require('./port-resolver');
 
 /**
  * Read developer ID from config file synchronously
@@ -157,7 +158,7 @@ function extractEnvVarsFromContent(envContent, envVars) {
  * @returns {Promise<string>} Patched env content
  */
 async function patchEnvContentForLocal(envContent, variables) {
-  const baseAppPort = variables.build?.localPort || variables.port || 3000;
+  const baseAppPort = getLocalPort(variables, 3000);
   const appPort = calculateDevAppPort(baseAppPort);
   const devIdNum = readDeveloperIdFromConfig(config) || 0;
   const infraPorts = devConfig.getDevPorts(devIdNum);

package/lib/utils/env-map.js

@@ -297,6 +297,7 @@ async function buildEnvVarMap(context, osModule = null, developerId = null) {
 }
 
 module.exports = {
-  buildEnvVarMap
+  buildEnvVarMap,
+  getDeveloperIdNumber
 };
 

package/lib/utils/env-ports.js

@@ -11,6 +11,7 @@
 const fs = require('fs');
 const yaml = require('js-yaml');
 const config = require('../core/config');
+const { getLocalPort } = require('./port-resolver');
 
 /**
  * Update PORT in the container's .env file to use variables.port (+offset)
@@ -66,7 +67,7 @@ function updateContainerPortInEnvFile(envPath, variablesPath) {
   }
   const variablesContent = fs.readFileSync(variablesPath, 'utf8');
   const variables = yaml.load(variablesContent);
-  const basePort = variables?.port || 3000;
+  const basePort = getLocalPort(variables, 3000);
   const devIdNum = getDeveloperIdFromEnvOrConfig();
   const port = calculatePortWithDevId(basePort, devIdNum);
   let envContent = fs.readFileSync(envPath, 'utf8');

package/lib/utils/env-template.js

@@ -20,7 +20,7 @@ const logger = require('../utils/logger');
  * @param {string} appKey - Application key
  * @param {string} clientIdKey - Secret key for client ID (e.g., 'myapp-client-idKeyVault')
  * @param {string} clientSecretKey - Secret key for client secret (e.g., 'myapp-client-secretKeyVault')
- * @param {string} _controllerUrl - Controller URL (e.g., 'http://localhost:3010' or 'https://controller.aifabrix.ai')
+ * @param {string} _controllerUrl - Controller URL (e.g., 'http://localhost:3010' or 'https://controller.aifabrix.dev')
  *   Note: This parameter is accepted for compatibility but the template format http://${MISO_HOST}:${MISO_PORT} is used instead
  * @returns {Promise<void>} Resolves when template is updated
  */

package/lib/utils/error-formatter.js

@@ -10,45 +10,145 @@
  */
 
 /**
- * Formats a single validation error into a developer-friendly message
- *
- * @function formatSingleError
- * @param {Object} error - Raw validation error from Ajv
- * @returns {string} Formatted error message
+ * Maps common regex patterns to human-readable descriptions
+ * @type {Object.<string, string>}
  */
-function formatSingleError(error) {
-  // Handle empty or missing instancePath - use 'Configuration' for root level errors
+const PATTERN_DESCRIPTIONS = {
+  '^[a-z0-9-]+$': 'lowercase letters, numbers, and hyphens only',
+  '^[a-z0-9-:]+$': 'lowercase letters, numbers, hyphens, and colons only (e.g., "entity:action")',
+  '^[a-z-]+$': 'lowercase letters and hyphens only',
+  '^[A-Z_][A-Z0-9_]*$': 'uppercase letters, numbers, and underscores (must start with letter or underscore)',
+  '^[a-zA-Z0-9_-]+$': 'letters, numbers, hyphens, and underscores only',
+  '^(http|https)://.*$': 'valid HTTP or HTTPS URL',
+  '^/[a-z0-9/-]*$': 'URL path starting with / (lowercase letters, numbers, hyphens, slashes)'
+};
+
+/**
+ * Gets a human-readable description of a regex pattern
+ * @function getPatternDescription
+ * @param {string} pattern - The regex pattern
+ * @returns {string} Human-readable description
+ */
+function getPatternDescription(pattern) {
+  return PATTERN_DESCRIPTIONS[pattern] || `must match pattern: ${pattern}`;
+}
+
+/**
+ * Extracts the field name from an error's instancePath
+ * @function getFieldName
+ * @param {Object} error - Validation error object
+ * @returns {string} Formatted field name
+ */
+function getFieldName(error) {
   const instancePath = error.instancePath || '';
   const path = instancePath ? instancePath.slice(1) : '';
-  const field = path ? `Field "${path}"` : 'Configuration';
+  return path ? `Field "${path}"` : 'Configuration';
+}
+
+/**
+ * Formats a pattern validation error with the actual invalid value
+ * @function formatPatternError
+ * @param {string} field - Field name
+ * @param {Object} error - Validation error object
+ * @returns {string} Formatted error message
+ */
+function formatPatternError(field, error) {
+  const invalidValue = error.data !== undefined ? `"${error.data}"` : 'value';
+  const patternDesc = getPatternDescription(error.params?.pattern);
+  return `${field}: Invalid value ${invalidValue} - ${patternDesc}`;
+}
+
+/**
+ * Formats additionalProperties validation errors
+ * @function formatAdditionalPropertiesError
+ * @param {string} field - Field name
+ * @param {Object} error - Validation error object
+ * @returns {string} Formatted error message
+ */
+function formatAdditionalPropertiesError(field, error) {
+  const invalidProperty = error.params?.additionalProperty;
+  const parentSchema = error.parentSchema || {};
+  const allowedProps = parentSchema.properties ? Object.keys(parentSchema.properties) : [];
+  const lines = [`${field}: must NOT have additional properties`];
+
+  if (invalidProperty) {
+    lines.push(`  Invalid property: "${invalidProperty}" (not allowed)`);
+  }
+  if (allowedProps.length > 0) {
+    lines.push(`  Allowed properties: ${allowedProps.join(', ')}`);
+  }
+  if ((error.instancePath || '').includes('/portalInput/validation')) {
+    lines.push('  Example: { "minLength": 1, "maxLength": 1000, "pattern": "^[0-9]+$", "required": false }');
+  }
+
+  return lines.join('\n');
+}
 
-  // Check if params exists before accessing it
-  const errorMessages = {
-    required: error.params?.missingProperty
-      ? `${field}: Missing required property "${error.params.missingProperty}"`
+/**
+ * Creates error message formatters for each validation keyword
+ * @function createKeywordFormatters
+ * @param {string} field - Field name
+ * @param {Object} error - Validation error object
+ * @returns {Object} Object mapping keywords to formatted messages
+ */
+function createKeywordFormatters(field, error) {
+  const params = error.params || {};
+
+  return {
+    required: params.missingProperty
+      ? `${field}: Missing required property "${params.missingProperty}"`
       : `${field}: Missing required property`,
-    type: error.params?.type
-      ? `${field}: Expected ${error.params.type}, got ${typeof error.data}`
+
+    type: params.type
+      ? `${field}: Expected ${params.type}, got ${typeof error.data}`
       : `${field}: Type error`,
-    minimum: error.params?.limit
-      ? `${field}: Value must be at least ${error.params.limit}`
+
+    minimum: params.limit !== undefined
+      ? `${field}: Value must be at least ${params.limit}`
       : `${field}: Value below minimum`,
-    maximum: error.params?.limit
-      ? `${field}: Value must be at most ${error.params.limit}`
+
+    maximum: params.limit !== undefined
+      ? `${field}: Value must be at most ${params.limit}`
       : `${field}: Value above maximum`,
-    minLength: error.params?.limit
-      ? `${field}: Must be at least ${error.params.limit} characters`
+
+    minLength: params.limit !== undefined
+      ? `${field}: Must be at least ${params.limit} characters`
       : `${field}: Too short`,
-    maxLength: error.params?.limit
-      ? `${field}: Must be at most ${error.params.limit} characters`
+
+    maxLength: params.limit !== undefined
+      ? `${field}: Must be at most ${params.limit} characters`
       : `${field}: Too long`,
-    pattern: `${field}: Invalid format`,
-    enum: error.params?.allowedValues && error.params.allowedValues.length > 0
-      ? `${field}: Must be one of: ${error.params.allowedValues.join(', ')}`
+
+    enum: params.allowedValues && params.allowedValues.length > 0
+      ? `${field}: Must be one of: ${params.allowedValues.join(', ')}`
       : `${field}: Must be one of: unknown`
   };
+}
 
-  return errorMessages[error.keyword] || `${field}: ${error.message || 'Validation error'}`;
+/**
+ * Formats a single validation error into a developer-friendly message
+ *
+ * @function formatSingleError
+ * @param {Object} error - Raw validation error from Ajv
+ * @returns {string} Formatted error message
+ */
+function formatSingleError(error) {
+  const field = getFieldName(error);
+
+  // Handle pattern errors with special formatting
+  if (error.keyword === 'pattern') {
+    return formatPatternError(field, error);
+  }
+  if (error.keyword === 'additionalProperties') {
+    return formatAdditionalPropertiesError(field, error);
+  }
+
+  // Use object lookup for keyword-specific messages
+  const formatters = createKeywordFormatters(field, error);
+  const message = formatters[error.keyword];
+
+  // Return keyword message or fallback to generic message
+  return message || `${field}: ${error.message || 'Validation error'}`;
 }
 
 /**
@@ -71,8 +171,29 @@ function formatValidationErrors(errors) {
   return errors.map(formatSingleError);
 }
 
+/**
+ * Formats the error when a required DB password variable is missing.
+ * Supports single-db (DB_0_PASSWORD or DB_PASSWORD) and multi-db (DB_0_PASSWORD, DB_1_PASSWORD, ...).
+ * @param {string} appKey - Application key
+ * @param {Object} opts - Options
+ * @param {boolean} [opts.multiDb] - True when multiple databases; required passwordKey is used, no hardcoded index
+ * @param {string} [opts.passwordKey] - The missing variable name (e.g. 'DB_1_PASSWORD'); required when multiDb is true
+ * @returns {string} Error message with next steps
+ */
+function formatMissingDbPasswordError(appKey, opts = {}) {
+  const { multiDb, passwordKey } = opts;
+  if (multiDb && passwordKey) {
+    return 'Missing required password variable ' + passwordKey + ' in .env file for application \'' + appKey + '\'. ' +
+      'Add ' + passwordKey + '=your_secret to your .env file. For multiple databases you need DB_0_PASSWORD, DB_1_PASSWORD, etc.';
+  }
+  return 'Missing required password variable DB_0_PASSWORD or DB_PASSWORD in .env file for application \'' + appKey + '\'. ' +
+    'This app has requires.database or databases in variables.yaml. Add DB_0_PASSWORD=your_secret or DB_PASSWORD=your_secret to builder/' + appKey + '/.env (or run \'aifabrix resolve ' + appKey + '\'), or set requires.database: false in variables.yaml if not needed.';
+}
+
 module.exports = {
   formatSingleError,
-  formatValidationErrors
+  formatValidationErrors,
+  formatMissingDbPasswordError,
+  getPatternDescription,
+  PATTERN_DESCRIPTIONS
 };
-

package/lib/utils/external-readme.js

@@ -0,0 +1,125 @@
+/**
+ * External System README Generation
+ *
+ * Provides a shared Handlebars-based README generator for external systems.
+ *
+ * @fileoverview External system README generation utilities
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const handlebars = require('handlebars');
+const { getProjectRoot } = require('./paths');
+
+/**
+ * Formats a display name from a key
+ * @param {string} key - System or app key
+ * @returns {string} Display name
+ */
+function formatDisplayName(key) {
+  if (!key || typeof key !== 'string') {
+    return 'External System';
+  }
+  return key
+    .split('-')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+}
+
+/**
+ * Normalizes datasource entries for template use
+ * @param {Array} datasources - Datasource objects
+ * @param {string} systemKey - System key for filename generation
+ * @returns {Array<{entityType: string, displayName: string, fileName: string}>} Normalized entries
+ */
+function normalizeDatasources(datasources, systemKey) {
+  if (!Array.isArray(datasources)) {
+    return [];
+  }
+  return datasources.map((datasource, index) => {
+    const entityType = datasource.entityType ||
+      datasource.entityKey ||
+      datasource.key?.split('-').pop() ||
+      `entity${index + 1}`;
+    const displayName = datasource.displayName ||
+      datasource.name ||
+      `Datasource ${index + 1}`;
+    let fileName = datasource.fileName || datasource.file;
+    if (!fileName) {
+      const key = datasource.key || '';
+      // Extract entity from keys like "hubspot-deploy-company" -> "company"
+      const entity = (systemKey && key.startsWith(`${systemKey}-deploy-`))
+        ? key.slice(`${systemKey}-deploy-`.length)
+        : entityType;
+      fileName = systemKey ? `${systemKey}-datasource-${entity}.json` : `${entity}.json`;
+    }
+    return { entityType, displayName, fileName };
+  });
+}
+
+/**
+ * Builds the external system README template context
+ * @function buildExternalReadmeContext
+ * @param {Object} params - Context parameters
+ * @param {string} [params.appName] - Application name
+ * @param {string} [params.systemKey] - System key
+ * @param {string} [params.systemType] - System type
+ * @param {string} [params.displayName] - Display name
+ * @param {string} [params.description] - Description
+ * @param {Array} [params.datasources] - Datasource objects
+ * @returns {Object} Template context
+ */
+function buildExternalReadmeContext(params = {}) {
+  const appName = params.appName || params.systemKey || 'external-system';
+  const systemKey = params.systemKey || appName;
+  const displayName = params.displayName || formatDisplayName(systemKey);
+  const description = params.description || `External system integration for ${systemKey}`;
+  const systemType = params.systemType || 'openapi';
+  const datasources = normalizeDatasources(params.datasources, systemKey);
+
+  return {
+    appName,
+    systemKey,
+    displayName,
+    description,
+    systemType,
+    datasourceCount: datasources.length,
+    datasources
+  };
+}
+
+/**
+ * Loads and compiles the external system README template
+ * @returns {Function} Compiled template
+ * @throws {Error} If template is missing
+ */
+function loadExternalReadmeTemplate() {
+  const projectRoot = getProjectRoot();
+  const templatePath = path.join(projectRoot, 'templates', 'external-system', 'README.md.hbs');
+  if (!fs.existsSync(templatePath)) {
+    throw new Error(`External system README template not found at ${templatePath}`);
+  }
+  const content = fs.readFileSync(templatePath, 'utf8');
+  return handlebars.compile(content);
+}
+
+/**
+ * Generates README content for an external system
+ * @function generateExternalReadmeContent
+ * @param {Object} params - Context parameters
+ * @returns {string} README content
+ */
+function generateExternalReadmeContent(params = {}) {
+  const template = loadExternalReadmeTemplate();
+  const context = buildExternalReadmeContext(params);
+  return template(context);
+}
+
+module.exports = {
+  buildExternalReadmeContext,
+  generateExternalReadmeContent
+};