@aifabrix/builder 2.40.2 → 2.42.0

package/lib/api/wizard-platform.api.js

@@ -0,0 +1,61 @@
+/**
+ * @fileoverview Wizard platform API - getPlatformDetails, discoverEntities
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { ApiClient } = require('./index');
+
+/**
+ * Get platform details including available datasources
+ * GET /api/v1/wizard/platforms/{platformKey}
+ * @requiresPermission {Dataplane} external-system:read
+ * @async
+ * @function getPlatformDetails
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} platformKey - Platform key (e.g. 'hubspot')
+ * @returns {Promise<Object>} Platform details including datasources: [{ key, displayName, entity }]
+ * @throws {Error} If request fails or platform not found (404)
+ */
+async function getPlatformDetails(dataplaneUrl, authConfig, platformKey) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  const response = await client.get(`/api/v1/wizard/platforms/${encodeURIComponent(platformKey)}`);
+  if (!response.success) {
+    const msg = response.status === 404
+      ? `Platform '${platformKey}' not found`
+      : response.formattedError || response.error || 'Failed to get platform details';
+    const err = new Error(msg);
+    err.status = response.status;
+    throw err;
+  }
+  return response;
+}
+
+/**
+ * Discover entities from OpenAPI spec (for multi-entity flows)
+ * POST /api/v1/wizard/discover-entities
+ * @requiresPermission {Dataplane} external-system:create
+ * @async
+ * @function discoverEntities
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} openapiSpec - OpenAPI specification object
+ * @returns {Promise<Object>} Response with entities: [{ name, pathCount, schemaMatch }]
+ * @throws {Error} If request fails
+ */
+async function discoverEntities(dataplaneUrl, authConfig, openapiSpec) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  const response = await client.post('/api/v1/wizard/discover-entities', {
+    body: { openapiSpec }
+  });
+  if (!response.success) {
+    const msg = response.formattedError || response.error || 'Failed to discover entities';
+    const err = new Error(msg);
+    err.status = response.status;
+    throw err;
+  }
+  return response;
+}
+
+module.exports = { getPlatformDetails, discoverEntities };

package/lib/api/wizard.api.js

@@ -6,6 +6,7 @@
 
 const { ApiClient } = require('./index');
 const { uploadFile } = require('../utils/file-upload');
+const { getPlatformDetails, discoverEntities } = require('./wizard-platform.api');
 
 /**
  * Create wizard session
@@ -178,8 +179,36 @@ async function detectType(dataplaneUrl, authConfig, openapiSpec) {
 }
 
 /**
- * Generate configuration via AI
+ * Get platform configuration for a known platform (no OpenAPI parsing)
+ * POST /api/v1/wizard/platforms/{platformKey}/config
+ * Use this when sourceType=known-platform; do NOT use generate-config which requires openapiSpec.
+ * @requiresPermission {Dataplane} external-system:create
+ * @async
+ * @function getPlatformConfig
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} platformKey - Platform key (e.g. 'hubspot')
+ * @param {Object} config - Configuration payload (no openapiSpec)
+ * @param {string} config.mode - Wizard mode ('create-system' | 'add-datasource')
+ * @param {string} [config.systemIdOrKey] - Existing system ID/key (required for add-datasource)
+ * @param {string} [config.credentialIdOrKey] - Credential ID or key
+ * @param {string} [config.intent] - User intent
+ * @param {string} [config.fieldOnboardingLevel] - Field onboarding level ('full' | 'standard' | 'minimal')
+ * @param {Object} [config.userPreferences] - User preferences
+ * @returns {Promise<Object>} Generated configuration response
+ * @throws {Error} If request fails
+ */
+async function getPlatformConfig(dataplaneUrl, authConfig, platformKey, config) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post(`/api/v1/wizard/platforms/${encodeURIComponent(platformKey)}/config`, {
+    body: config
+  });
+}
+
+/**
+ * Generate configuration via AI (OpenAPI-based)
  * POST /api/v1/wizard/generate-config
+ * Do NOT use for sourceType=known-platform; use getPlatformConfig instead.
  * @requiresPermission {Dataplane} external-system:create
  * @async
  * @function generateConfig
@@ -198,6 +227,7 @@ async function detectType(dataplaneUrl, authConfig, openapiSpec) {
  * @param {boolean} [config.userPreferences.enableMCP] - Enable MCP
  * @param {boolean} [config.userPreferences.enableABAC] - Enable ABAC
  * @param {boolean} [config.userPreferences.enableRBAC] - Enable RBAC
+ * @param {string} [config.entityName] - Entity for multi-entity OpenAPI (from discover-entities)
  * @returns {Promise<Object>} Generated configuration response
  * @throws {Error} If request fails
  */
@@ -417,6 +447,9 @@ module.exports = {
   parseOpenApi,
   credentialSelection,
   detectType,
+  getPlatformDetails,
+  discoverEntities,
+  getPlatformConfig,
   generateConfig,
   generateConfigStream,
   validateWizardConfig,

package/lib/app/config.js

@@ -15,6 +15,7 @@ const { generateVariablesYaml, generateEnvTemplate, generateRbacYaml } = require
 const { generateEnvTemplate: generateEnvTemplateFromReader } = require('../core/env-reader');
 const { generateReadmeMdFile } = require('./readme');
 const logger = require('../utils/logger');
+const { systemKeyToKvPrefix } = require('../utils/credential-secrets-env');
 
 /**
  * Checks if a file exists
@@ -31,6 +32,26 @@ async function fileExists(filePath) {
   }
 }
 
+/**
+ * Renames legacy variables.yaml to application.yaml if only variables.yaml exists.
+ * Ensures create always results in application.yaml.
+ * @async
+ * @param {string} appPath - Path to application directory
+ */
+async function normalizeLegacyVariablesYaml(appPath) {
+  const applicationYaml = path.join(appPath, 'application.yaml');
+  const applicationYml = path.join(appPath, 'application.yml');
+  const applicationJson = path.join(appPath, 'application.json');
+  const variablesYaml = path.join(appPath, 'variables.yaml');
+  const hasAppYaml = await fileExists(applicationYaml);
+  const hasAppYml = await fileExists(applicationYml);
+  const hasAppJson = await fileExists(applicationJson);
+  const hasVariables = await fileExists(variablesYaml);
+  if (hasVariables && !hasAppYaml && !hasAppYml && !hasAppJson) {
+    await fs.rename(variablesYaml, applicationYaml);
+  }
+}
+
 /**
  * Generates application.yaml file if no application config exists
  * @async
@@ -39,6 +60,7 @@ async function fileExists(filePath) {
  * @param {Object} config - Application configuration
  */
 async function generateVariablesYamlFile(appPath, appName, config) {
+  await normalizeLegacyVariablesYaml(appPath);
   const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
   try {
     resolveApplicationConfigPath(appPath);
@@ -52,7 +74,8 @@ async function generateVariablesYamlFile(appPath, appName, config) {
 }
 
 /**
- * Generates env.template content for external systems based on authentication type
+ * Generates env.template content for external systems based on authentication type.
+ * Uses KV_<APPKEY>_<VAR> convention (e.g. KV_HUBSPOT_CLIENTID) for credential push.
  * @param {Object} config - Application configuration with authType and systemKey
  * @param {string} appName - Application name (used as fallback for systemKey)
  * @returns {string} Environment template content
@@ -60,23 +83,33 @@ async function generateVariablesYamlFile(appPath, appName, config) {
 function generateExternalSystemEnvTemplate(config, appName) {
   const systemKey = config.systemKey || appName;
   const authType = config.authType || 'apikey';
+  const prefix = systemKeyToKvPrefix(systemKey);
+  if (!prefix) return '';
+
   const lines = [
-    `# ${systemKey} ${authType.toUpperCase()} Configuration`,
-    '# These values are set via the Miso Controller interface or Dataplane portal',
-    '# Values are stored in Key Vault automatically by the platform',
+    `# ${systemKey} ${String(authType).toUpperCase()} Configuration`,
+    '# Use KV_* variables for credential push (aifabrix credential push).',
+    '# Values are stored in Key Vault automatically by the platform.',
     ''
   ];
 
-  if (authType === 'oauth2') {
-    lines.push('CLIENTID=kv://' + systemKey + '-clientidKeyVault');
-    lines.push('CLIENTSECRET=kv://' + systemKey + '-clientsecretKeyVault');
-    lines.push('TOKENURL=https://api.example.com/oauth/token');
+  if (authType === 'oauth2' || authType === 'aad') {
+    lines.push(`KV_${prefix}_CLIENTID=`);
+    lines.push(`KV_${prefix}_CLIENTSECRET=`);
+    lines.push('TOKEN_URL=https://api.example.com/oauth/token');
   } else if (authType === 'apikey') {
-    lines.push('API_KEY=kv://' + systemKey + '-api-keyKeyVault');
+    lines.push(`KV_${prefix}_APIKEY=`);
   } else if (authType === 'basic') {
-    lines.push('USERNAME=kv://' + systemKey + '-usernameKeyVault');
-    lines.push('PASSWORD=kv://' + systemKey + '-passwordKeyVault');
+    lines.push(`KV_${prefix}_USERNAME=`);
+    lines.push(`KV_${prefix}_PASSWORD=`);
+  } else if (authType === 'queryParam') {
+    lines.push(`KV_${prefix}_PARAMVALUE=`);
+  } else if (authType === 'oidc') {
+    lines.push('# OIDC: variables only (openIdConfigUrl, clientId); no security keys');
+  } else if (authType === 'hmac') {
+    lines.push(`KV_${prefix}_SIGNINGSECRET=`);
   }
+  // none: no security keys
 
   return lines.join('\n');
 }

package/lib/app/down.js

@@ -118,6 +118,7 @@ async function downApp(appName, options = {}) {
 }
 
 module.exports = {
-  downApp
+  downApp,
+  getAppVolumeName
 };
 

package/lib/app/index.js

@@ -31,6 +31,8 @@ const {
   processTemplateFiles,
   setupAppFiles
 } = require('./helpers');
+const path = require('path');
+const secretsEnsure = require('../core/secrets-ensure');
 
 /**
  * Creates new application with scaffolded configuration files
@@ -130,10 +132,19 @@ async function generateApplicationFiles(finalAppPath, appName, config, options)
 
   await generateConfigFiles(finalAppPath, appName, config, existingEnv);
 
+  const envTemplatePath = path.join(finalAppPath, 'env.template');
+  try {
+    await secretsEnsure.ensureSecretsFromEnvTemplate(envTemplatePath, {});
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+  }
+
   // Generate external system files if type is external
   if (config.type === 'external') {
+    const configModule = require('../core/config');
+    const format = (await configModule.getFormat()) || 'yaml';
     const externalGenerator = require('../external-system/generator');
-    await externalGenerator.generateExternalSystemFiles(finalAppPath, appName, config);
+    await externalGenerator.generateExternalSystemFiles(finalAppPath, appName, config, format);
   }
 
   if (options.app) {

package/lib/app/prompts.js

@@ -176,8 +176,13 @@ function buildExternalSystemTypeQuestions(options) {
       message: 'What authentication type does the system use?',
       choices: [
         { name: 'OAuth2', value: 'oauth2' },
+        { name: 'Azure AD', value: 'aad' },
         { name: 'API Key', value: 'apikey' },
-        { name: 'Basic Auth', value: 'basic' }
+        { name: 'Basic Auth', value: 'basic' },
+        { name: 'Query Parameter', value: 'queryParam' },
+        { name: 'OpenID Connect', value: 'oidc' },
+        { name: 'HMAC Signature', value: 'hmac' },
+        { name: 'None', value: 'none' }
       ],
       default: 'apikey'
     });
@@ -185,6 +190,28 @@ function buildExternalSystemTypeQuestions(options) {
   return questions;
 }
 
+/**
+ * Build entityType question for external system datasources
+ * @param {Object} options - Provided options
+ * @returns {Array} Array of question objects
+ */
+function buildEntityTypeQuestion(options) {
+  if (options.entityType) return [];
+  return [{
+    type: 'list',
+    name: 'entityType',
+    message: 'What entity type do the datasources represent?',
+    choices: [
+      { name: 'Record storage (CRM, deals, contacts)', value: 'recordStorage' },
+      { name: 'Document storage (with vector)', value: 'documentStorage' },
+      { name: 'Vector store', value: 'vectorStore' },
+      { name: 'Message service', value: 'messageService' },
+      { name: 'None', value: 'none' }
+    ],
+    default: 'recordStorage'
+  }];
+}
+
 function buildExternalSystemDatasourceQuestion(options) {
   if (options.datasourceCount) return [];
   return [{
@@ -210,6 +237,7 @@ function buildExternalSystemQuestions(options, appName) {
   return [
     ...buildExternalSystemIdentityQuestions(options, appName),
     ...buildExternalSystemTypeQuestions(options),
+    ...buildEntityTypeQuestion(options),
     ...buildExternalSystemDatasourceQuestion(options)
   ];
 }
@@ -325,6 +353,16 @@ function resolveExternalSystemField(options, answers, fieldName, defaultValue) {
   return null;
 }
 
+const EXTERNAL_SYSTEM_FIELD_SPECS = [
+  { key: 'systemKey', default: undefined },
+  { key: 'systemDisplayName', default: undefined },
+  { key: 'systemDescription', default: undefined },
+  { key: 'systemType', default: 'openapi' },
+  { key: 'authType', default: 'apikey' },
+  { key: 'entityType', default: 'recordStorage' },
+  { key: 'datasourceCount', default: 1, transform: (v) => parseInt(v, 10) }
+];
+
 /**
  * Resolve external system fields and add to config
  * @function resolveExternalSystemFields
@@ -334,34 +372,11 @@ function resolveExternalSystemField(options, answers, fieldName, defaultValue) {
  * @returns {void}
  */
 function resolveExternalSystemFields(options, answers, config) {
-  const systemKey = resolveExternalSystemField(options, answers, 'systemKey', undefined);
-  if (systemKey !== null) {
-    config.systemKey = systemKey;
-  }
-
-  const systemDisplayName = resolveExternalSystemField(options, answers, 'systemDisplayName', undefined);
-  if (systemDisplayName !== null) {
-    config.systemDisplayName = systemDisplayName;
-  }
-
-  const systemDescription = resolveExternalSystemField(options, answers, 'systemDescription', undefined);
-  if (systemDescription !== null) {
-    config.systemDescription = systemDescription;
-  }
-
-  const systemType = resolveExternalSystemField(options, answers, 'systemType', 'openapi');
-  if (systemType !== null) {
-    config.systemType = systemType;
-  }
-
-  const authType = resolveExternalSystemField(options, answers, 'authType', 'apikey');
-  if (authType !== null) {
-    config.authType = authType;
-  }
-
-  const datasourceCount = resolveExternalSystemField(options, answers, 'datasourceCount', 1);
-  if (datasourceCount !== null) {
-    config.datasourceCount = parseInt(datasourceCount, 10);
+  for (const { key, default: defaultValue, transform } of EXTERNAL_SYSTEM_FIELD_SPECS) {
+    const value = resolveExternalSystemField(options, answers, key, defaultValue);
+    if (value !== null) {
+      config[key] = transform ? transform(value) : value;
+    }
   }
 }
 

package/lib/app/push.js

@@ -40,21 +40,38 @@ function validateAppName(appName) {
 }
 
 /**
- * Extracts image name from configuration using the same logic as build command
- * @param {Object} config - Configuration object from application.yaml
- * @param {string} appName - Application name (fallback)
- * @returns {string} Image name
+ * Returns effective config (unwrap variables wrapper if present so image/app are at top level).
+ * application.yaml may have top-level image/app or a variables: { image, app } wrapper.
+ * @param {Object} config - Raw config from loadConfigFile
+ * @returns {Object} Config with image and app at top level
+ */
+function getEffectiveConfig(config) {
+  if (!config || typeof config !== 'object') return config || {};
+  if (config.variables && typeof config.variables === 'object' && (config.variables.image !== undefined || config.variables.app !== undefined)) {
+    return config.variables;
+  }
+  return config;
+}
+
+/**
+ * Extracts image name from configuration using the same logic as build command.
+ * Uses image.name (e.g. aifabrix/dataplane) so ACR repository matches application.yaml.
+ * @param {Object} config - Configuration object from application.yaml (or effective config)
+ * @param {string} appName - Application name (fallback when image not set)
+ * @returns {string} Image name (e.g. aifabrix/dataplane, not just dataplane)
  */
 function extractImageName(config, appName) {
-  if (typeof config.image === 'string') {
-    return config.image.split(':')[0];
-  } else if (config.image?.name) {
-    return config.image.name;
-  } else if (config.app?.key) {
-    return config.app.key;
+  const c = getEffectiveConfig(config);
+  if (typeof c.image === 'string') {
+    return c.image.split(':')[0];
+  }
+  if (c.image?.name) {
+    return c.image.name;
+  }
+  if (c.app?.key) {
+    return c.app.key;
   }
   return appName;
-
 }
 
 /**
@@ -72,7 +89,8 @@ async function loadPushConfig(appName, options) {
   try {
     const configPath = resolveApplicationConfigPath(appPath);
     const config = loadConfigFile(configPath);
-    const registry = options.registry || config.image?.registry;
+    const effective = getEffectiveConfig(config);
+    const registry = options.registry || effective.image?.registry;
     if (!registry) {
       throw new Error('Registry URL is required. Provide via --registry flag or configure in application config under image.registry');
     }
@@ -110,6 +128,12 @@ async function validatePushConfig(registry, imageName, appName) {
   if (!await pushUtils.checkAzureCLIInstalled()) {
     throw new Error('Azure CLI is not installed. Install from: https://docs.microsoft.com/cli/azure/install-azure-cli');
   }
+
+  if (!await pushUtils.checkAzureLogin()) {
+    throw new Error(
+      'Not logged in to Azure. Run "az login" first, then run push again.'
+    );
+  }
 }
 
 /**

package/lib/app/readme.js

@@ -92,20 +92,23 @@ function extractServiceFlags(config) {
 /**
  * Builds placeholder datasources for external README generation
  * @function buildExternalDatasourcePlaceholders
+ * @param {string} systemKey - System key
  * @param {number} datasourceCount - Datasource count
+ * @param {string} [fileExt='.json'] - File extension (e.g. '.json', '.yaml')
  * @returns {Array<Object>} Datasource placeholders
  */
-function buildExternalDatasourcePlaceholders(systemKey, datasourceCount) {
+function buildExternalDatasourcePlaceholders(systemKey, datasourceCount, fileExt = '.json') {
   const normalizedCount = Number.isInteger(datasourceCount)
     ? datasourceCount
     : parseInt(datasourceCount, 10);
   const total = Number.isFinite(normalizedCount) && normalizedCount > 0 ? normalizedCount : 0;
+  const ext = fileExt && fileExt.startsWith('.') ? fileExt : `.${fileExt || 'json'}`;
   return Array.from({ length: total }, (_value, index) => {
     const entityType = `entity${index + 1}`;
     return {
       entityType,
       displayName: `Datasource ${index + 1}`,
-      fileName: `${systemKey}-datasource-${entityType}.yaml`
+      fileName: `${systemKey}-datasource-${entityType}${ext}`
     };
   });
 }
@@ -120,9 +123,7 @@ function buildExternalDatasourcePlaceholders(systemKey, datasourceCount) {
 function buildReadmeContext(appName, config) {
   const displayName = config.displayName || formatAppDisplayName(appName);
   const port = config.port ?? 3000;
-  const localPort = (typeof config.build?.localPort === 'number' && config.build.localPort > 0)
-    ? config.build.localPort
-    : port;
+  const localPort = port;
   const imageName = config.image?.name || `aifabrix/${appName}`;
   // Extract registry from nested structure (config.image.registry) or flattened (config.registry)
   const registry = config.image?.registry || config.registry || 'myacr.azurecr.io';
@@ -145,15 +146,17 @@ function buildReadmeContext(appName, config) {
 function generateReadmeMd(appName, config) {
   if (config.type === 'external') {
     const systemKey = config.systemKey || appName;
+    const fileExt = config.fileExt !== undefined ? config.fileExt : '.json';
     const datasources = Array.isArray(config.datasources) && config.datasources.length > 0
       ? config.datasources
-      : buildExternalDatasourcePlaceholders(systemKey, config.datasourceCount);
+      : buildExternalDatasourcePlaceholders(systemKey, config.datasourceCount, fileExt);
     return generateExternalReadmeContent({
       appName,
       systemKey,
       systemType: config.systemType,
       displayName: config.systemDisplayName,
       description: config.systemDescription,
+      fileExt: config.fileExt,
       datasources
     });
   }