@aifabrix/builder 2.49.2 → 2.50.0

package/lib/channels/channel-status-display.js

@@ -1,5 +1,5 @@
 /**
- * TTY output for app add-channel (plan 152).
+ * TTY output for channel add (plan 152).
  *
  * @fileoverview Channel install status display — customer language: Assistant
  * @author AI Fabrix Team
@@ -26,32 +26,79 @@ function separatorLine() {
     : '────────────────────────────────────────';
 }
 
+/**
+ * @param {Object|null} approvalGuide
+ */
+function displayApprovalGuideOptionalLinks(approvalGuide) {
+  if (approvalGuide.artifactPath) {
+    logger.log('');
+    logger.log(metadata('Manifest file:'));
+    logger.log(chalk.white(approvalGuide.artifactPath));
+  }
+  if (approvalGuide.credentialPortalUrl) {
+    logger.log('');
+    logger.log(metadata('AI Fabrix authentication:'));
+    logger.log(chalk.cyan(approvalGuide.credentialPortalUrl));
+  }
+  if (approvalGuide.installGuidePath) {
+    logger.log('');
+    logger.log(metadata(`Full guide: ${approvalGuide.installGuidePath}`));
+  }
+}
+
+/**
+ * @param {Object|null} approvalGuide
+ */
+function displayApprovalGuideSection(approvalGuide) {
+  if (!approvalGuide?.steps?.length) return;
+  logger.log('');
+  const heading =
+    approvalGuide.approvalRequired === false
+      ? 'Go-live steps'
+      : 'Platform admin approval required';
+  logger.log(formatWarningLine(heading));
+  if (approvalGuide.portalUrl) {
+    logger.log(metadata('Admin console:'));
+    logger.log(chalk.cyan(approvalGuide.portalUrl));
+  }
+  logger.log('');
+  logger.log(metadata('Next steps:'));
+  approvalGuide.steps.forEach((step, index) => {
+    logger.log(chalk.white(`  ${index + 1}. ${step}`));
+  });
+  displayApprovalGuideOptionalLinks(approvalGuide);
+}
+
 /**
  * @param {Object} params
  * @param {string} params.channelTarget
  * @param {string} params.name
  * @param {Object|null} params.channelExt
- * @param {string} [params.approvalUrl]
+ * @param {Object|null} [params.approvalGuide]
  */
 function displayExistingChannelStatus(params) {
-  logger.log(sectionTitle(`${params.channelTarget} channel: ${params.name}`));
-  logger.log('');
-  logger.log(metadata(`Status: ${params.channelExt?.status || 'unknown'}`));
-  if (params.channelExt?.baseName && params.channelExt.baseName !== params.name) {
-    logger.log(metadata(`Base name: ${params.channelExt.baseName}`));
-  }
-  logger.log(metadata(`External System: ${params.channelTarget}`));
-  logger.log(metadata(`Credential: ${params.channelExt?.credentialKey || '—'}`));
-  if (params.channelExt?.capabilities?.length) {
-    logger.log(metadata('Capabilities:'));
-    for (const cap of params.channelExt.capabilities) {
-      logger.log(`  - ${cap}`);
-    }
+  const status = params.channelExt?.status || 'unknown';
+  displayChannelCoreFields({
+    channelTarget: params.channelTarget,
+    name: params.name,
+    statusLabel: status,
+    baseName: params.channelExt?.baseName,
+    credentialKey: params.channelExt?.credentialKey,
+    capabilities: params.channelExt?.capabilities
+  });
+
+  if (status === 'approvalRequired' && params.approvalGuide) {
+    displayApprovalGuideSection(params.approvalGuide);
+    logger.log(separatorLine());
+    return;
   }
+
   logger.log('');
-  logger.log(formatWarningLine('Channel install already configured. Use --force to regenerate artifacts.'));
-  if (params.approvalUrl) {
-    logger.log(metadata(`Approval URL: ${params.approvalUrl}`));
+  if (status === 'installed' || status === 'validated') {
+    logger.log(formatSuccessLine('Channel install is complete.'));
+    logger.log(metadata('Use --force to regenerate artifacts and patch config.'));
+  } else {
+    logger.log(formatWarningLine('Channel install already configured. Use --force to regenerate artifacts.'));
   }
   logger.log(separatorLine());
 }
@@ -107,14 +154,7 @@ function displayValidationSection(validation) {
  * @param {Object} result
  */
 function displayApprovalSection(result) {
-  if (!result.approvalUrl) return;
-  logger.log('');
-  logger.log(formatWarningLine('Approval required'));
-  logger.log(metadata('Open this URL as platform admin:'));
-  logger.log(chalk.cyan(result.approvalUrl));
-  logger.log('');
-  logger.log(metadata('After approval, run:'));
-  logger.log(chalk.white(`  aifabrix app add-channel ${result.channelTarget} --name "${result.name}"`));
+  displayApprovalGuideSection(result.approvalGuide);
 }
 
 /**

package/lib/channels/channel-targets.js

@@ -10,7 +10,7 @@
 
 /** @typedef {'teams-bot'|'slack'|'microsoft-copilot'|'chatgpt'|'web-embed'} ChannelTargetKey */
 
-const DEFAULT_CAPABILITIES = ['chat', 'notify'];
+const DEFAULT_CAPABILITIES = ['chat', 'notify', 'documentApproval'];
 
 const CHANNEL_TARGETS = {
   'teams-bot': {
@@ -101,8 +101,8 @@ function getChannelTarget(channelTarget) {
  */
 function getDefaultChannelDescription() {
   return (
-    'Enterprise AI assistant for employees. Provides access to approved assistants, ' +
-    'enterprise knowledge, business workflows, and governed actions through AI Fabrix.'
+    'Enterprise AI assistant for employees. Approved assistants, enterprise knowledge, ' +
+    'workflows, and governed actions via AI Fabrix.'
   );
 }
 

package/lib/cli/index.js

@@ -23,15 +23,19 @@ const { setupAppCommands: setupAppManagementCommands } = require('../commands/ap
 const { setupDatasourceCommands } = require('../commands/datasource');
 const { setupDimensionCommands } = require('../commands/dimension');
 const { setupResourceTypeCommands } = require('../commands/resource-type');
+const { setupEnterpriseKnowledgeCommands } = require('../commands/enterprise-knowledge');
 const { setupIdentityCommands } = require('../commands/identity');
 const { setupProtectionCommands } = require('../commands/protection');
+const { setupEvidenceCommands } = require('../commands/evidence');
 const { setupCredentialDeploymentCommands } = require('./setup-credential-deployment');
 const { setupIntegrationClientCommands } = require('./setup-integration-client');
 const { setupPlatformCommands } = require('./setup-platform');
 const { setupCertificationCommands } = require('./setup-certification-commands');
 const { setupGovernanceCommands } = require('../commands/governance');
 const { setupChannelCommands } = require('../commands/channel');
+const { setupManifestCommands } = require('../commands/manifest');
 const { setupNpmCommands } = require('./setup-npm');
+const { setupListCommand } = require('./setup-list');
 
 /**
  * Dev, secrets, parameters, and platform commands (keeps setupCommands under statement limit).
@@ -46,10 +50,10 @@ function setupDevAndPlatformCommands(program) {
 }
 
 /**
- * Sets up all CLI commands on the Commander program instance
- * @param {Command} program - Commander program instance
+ * Core platform and integration CLI command groups.
+ * @param {import('commander').Command} program
  */
-function setupCommands(program) {
+function setupCoreCliCommands(program) {
   setupInfraCommands(program);
   setupAuthCommands(program);
   setupAppCommands(program);
@@ -59,14 +63,34 @@ function setupCommands(program) {
   setupAppManagementCommands(program);
   setupChannelCommands(program);
   setupDatasourceCommands(program);
+  setupManifestCommands(program);
+}
+
+/**
+ * Extended catalog and policy CLI command groups.
+ * @param {import('commander').Command} program
+ */
+function setupExtendedCliCommands(program) {
   setupDimensionCommands(program);
   setupResourceTypeCommands(program);
+  setupEnterpriseKnowledgeCommands(program);
   setupIdentityCommands(program);
   setupProtectionCommands(program);
+  setupEvidenceCommands(program);
   setupUtilityCommands(program);
+  setupListCommand(program);
   setupCredentialDeploymentCommands(program);
   setupIntegrationClientCommands(program);
   setupExternalSystemCommands(program);
+}
+
+/**
+ * Sets up all CLI commands on the Commander program instance
+ * @param {Command} program - Commander program instance
+ */
+function setupCommands(program) {
+  setupCoreCliCommands(program);
+  setupExtendedCliCommands(program);
   setupDevAndPlatformCommands(program);
 }
 

package/lib/cli/infra-guided.js

@@ -15,6 +15,7 @@ const infra = require('../infrastructure');
 const { execWithDockerEnv } = require('../utils/docker-exec');
 const { getLogLevel, passesLevelFilter } = require('../commands/app-logs');
 const { handleLogin } = require('../commands/login');
+const { handleUpBuilderApi } = require('../commands/up-builder-api');
 const {
   resolveGuidedAuthControllerUrl,
   runGuidedAuthStep,
@@ -309,7 +310,10 @@ async function runGuidedUpPlatform(options, handleUpMiso, handleUpDataplane, han
   await runGuidedAuthStep(handleLogin, authOpts, { startSpinner, stopSpinnerSuccess });
   const controllerUrl = await resolveGuidedAuthControllerUrl(authOpts);
   await runGuidedDataplaneInstallPhase(options, handleUpDataplane, handleLogin, controllerUrl);
-  await validateAppErrorLogs(['miso-controller', 'dataplane']);
+  const baSpin = startSpinner('Starting builder-api...');
+  await withMutedLogger(() => handleUpBuilderApi({ ...options, platformInstall: true }));
+  stopSpinnerSuccess(baSpin, 'Builder API ready');
+  await validateAppErrorLogs(['miso-controller', 'dataplane', 'builder-api']);
   await logPlatformReadyFooter();
 }
 

package/lib/cli/setup-app-external-create.js

@@ -0,0 +1,111 @@
+/**
+ * External-system create option normalization for setup-app.js.
+ *
+ * @fileoverview Headless external create CLI helpers
+ */
+
+const VALID_ENTITY_TYPES = ['recordStorage', 'documentStorage', 'vectorStore', 'messageService', 'none'];
+
+/**
+ * Normalize options for external system creation
+ * @param {Object} options - Raw CLI options
+ * @returns {Object} Normalized options
+ */
+function normalizeExternalOptions(options) {
+  const normalized = { ...options };
+  if (options.displayName) normalized.systemDisplayName = options.displayName;
+  if (options.description) normalized.systemDescription = options.description;
+  if (options.systemType) normalized.systemType = options.systemType;
+  if (options.authType) normalized.authType = options.authType;
+  if (options.entityType) {
+    if (!VALID_ENTITY_TYPES.includes(options.entityType)) {
+      throw new Error(`Invalid --entity-type. Must be one of: ${VALID_ENTITY_TYPES.join(', ')}`);
+    }
+    normalized.entityType = options.entityType;
+  }
+  if (options.datasources !== undefined) {
+    const parsedCount = parseInt(options.datasources, 10);
+    if (Number.isNaN(parsedCount) || parsedCount < 1 || parsedCount > 10) {
+      throw new Error('Datasources count must be a number between 1 and 10');
+    }
+    normalized.datasourceCount = parsedCount;
+  }
+  if (options.controller) {
+    normalized.controller = true;
+    normalized.controllerUrl = options.controller;
+  }
+  return normalized;
+}
+
+/**
+ * Whether normalized options include all external CLI fields for headless create.
+ * @param {Object} normalized - Normalized external create options
+ * @returns {boolean}
+ */
+function hasFullExternalCliOptions(normalized) {
+  return Boolean(
+    normalized.systemKey &&
+    normalized.systemDisplayName &&
+    normalized.systemDescription &&
+    normalized.systemType &&
+    normalized.authType &&
+    normalized.entityType &&
+    normalized.datasourceCount
+  );
+}
+
+/**
+ * Map positional systemKey and apply headless defaults for external create.
+ * @param {string} appName - Positional appKey or systemKey from CLI
+ * @param {Object} options - Raw CLI options
+ * @returns {Object} Normalized options ready for createApp
+ */
+function prepareExternalCreateOptions(appName, options) {
+  const normalized = normalizeExternalOptions(options);
+  const isExternalType = options.type === 'external' || !options.type;
+
+  if (isExternalType && appName) {
+    normalized.systemKey = appName;
+  }
+
+  if (isExternalType && hasFullExternalCliOptions(normalized)) {
+    if (!Object.prototype.hasOwnProperty.call(normalized, 'github')) {
+      normalized.github = false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(normalized, 'controller')) {
+      normalized.controller = false;
+    }
+  }
+
+  return normalized;
+}
+
+/**
+ * Validate required options for non-interactive external creation
+ * @param {Object} normalizedOptions - Normalized options
+ * @throws {Error} If required options are missing
+ */
+function validateNonInteractiveExternalOptions(normalizedOptions) {
+  const missing = [];
+  if (!normalizedOptions.systemDisplayName) missing.push('--display-name');
+  if (!normalizedOptions.systemDescription) missing.push('--description');
+  if (!normalizedOptions.systemType) missing.push('--system-type');
+  if (!normalizedOptions.authType) missing.push('--auth-type');
+  if (!normalizedOptions.entityType) missing.push('--entity-type');
+  if (!normalizedOptions.datasourceCount) missing.push('--datasources');
+  if (missing.length > 0) {
+    throw new Error(`Missing required options for non-interactive external create: ${missing.join(', ')}`);
+  }
+  if (!Object.prototype.hasOwnProperty.call(normalizedOptions, 'github')) {
+    normalizedOptions.github = false;
+  }
+  if (!Object.prototype.hasOwnProperty.call(normalizedOptions, 'controller')) {
+    normalizedOptions.controller = false;
+  }
+}
+
+module.exports = {
+  normalizeExternalOptions,
+  prepareExternalCreateOptions,
+  validateNonInteractiveExternalOptions
+};

package/lib/cli/setup-app.help.js

@@ -56,7 +56,7 @@ Examples:
 Notes:
   - To run E2E for one datasource, use:
       aifabrix datasource test-e2e <datasourceKey>
-  - External integration: local system and datasource files are published to the dataplane before E2E (same as upload). Use --no-sync to exercise only config already deployed.
+  - External integration: local system and datasource files are published to the dataplane before E2E (same as upload). Use --no-publish to exercise only config already deployed.
 `;
 
 const IDENTITY_HELP_AFTER = `

package/lib/cli/setup-app.js

@@ -13,6 +13,10 @@ const app = require('../app');
 const logger = require('../utils/logger');
 const { handleCommandError } = require('../utils/cli-utils');
 const { setupInstallTestE2eLintCommands } = require('./setup-app.test-commands');
+const {
+  prepareExternalCreateOptions,
+  validateNonInteractiveExternalOptions
+} = require('./setup-app-external-create');
 
 const CREATE_HELP_AFTER = `
 Examples:
@@ -46,13 +50,13 @@ Examples:
   $ aifabrix push myapp --registry $ACR_REGISTRY --tag $IMAGE_TAG
   $ aifabrix deploy myapp \\
       --client-id "$DEV_MISO_CLIENTID" \\
-      --client-secret "$DEV_MISO_CLIENTSECRET" \\
-      --no-poll
+      --client-secret "$DEV_MISO_CLIENTSECRET"
 
   # CI/CD — external integration (after upload/tests; promote to controller)
   $ aifabrix validate hubspot-demo
   $ aifabrix upload hubspot-demo --probe
-  $ aifabrix deploy hubspot-demo --probe --no-poll
+  $ aifabrix deploy hubspot-demo --probe -v
+  $ aifabrix deploy ek-sales --gate full --subject-email ops@example.com
 
 Notes:
   - Login or set MISO_CONTROLLER_URL + environment (aifabrix login / aifabrix auth).
@@ -79,106 +83,6 @@ Notes:
   - Use -t 0 (--tail 0) for the full buffered log; default is 100 lines.
 `;
 
-/**
- * Normalize options for external system creation
- * @param {Object} options - Raw CLI options
- * @returns {Object} Normalized options
- */
-const VALID_ENTITY_TYPES = ['recordStorage', 'documentStorage', 'vectorStore', 'messageService', 'none'];
-
-function normalizeExternalOptions(options) {
-  const normalized = { ...options };
-  if (options.displayName) normalized.systemDisplayName = options.displayName;
-  if (options.description) normalized.systemDescription = options.description;
-  if (options.systemType) normalized.systemType = options.systemType;
-  if (options.authType) normalized.authType = options.authType;
-  if (options.entityType) {
-    if (!VALID_ENTITY_TYPES.includes(options.entityType)) {
-      throw new Error(`Invalid --entity-type. Must be one of: ${VALID_ENTITY_TYPES.join(', ')}`);
-    }
-    normalized.entityType = options.entityType;
-  }
-  if (options.datasources !== undefined) {
-    const parsedCount = parseInt(options.datasources, 10);
-    if (Number.isNaN(parsedCount) || parsedCount < 1 || parsedCount > 10) {
-      throw new Error('Datasources count must be a number between 1 and 10');
-    }
-    normalized.datasourceCount = parsedCount;
-  }
-  if (options.controller) {
-    normalized.controller = true;
-    normalized.controllerUrl = options.controller;
-  }
-  return normalized;
-}
-
-/**
- * Whether normalized options include all external CLI fields for headless create.
- * @param {Object} normalized - Normalized external create options
- * @returns {boolean}
- */
-function hasFullExternalCliOptions(normalized) {
-  return Boolean(
-    normalized.systemKey &&
-    normalized.systemDisplayName &&
-    normalized.systemDescription &&
-    normalized.systemType &&
-    normalized.authType &&
-    normalized.entityType &&
-    normalized.datasourceCount
-  );
-}
-
-/**
- * Map positional systemKey and apply headless defaults for external create.
- * @param {string} appName - Positional appKey or systemKey from CLI
- * @param {Object} options - Raw CLI options
- * @returns {Object} Normalized options ready for createApp
- */
-function prepareExternalCreateOptions(appName, options) {
-  const normalized = normalizeExternalOptions(options);
-  const isExternalType = options.type === 'external' || !options.type;
-
-  if (isExternalType && appName) {
-    normalized.systemKey = appName;
-  }
-
-  if (isExternalType && hasFullExternalCliOptions(normalized)) {
-    if (!Object.prototype.hasOwnProperty.call(normalized, 'github')) {
-      normalized.github = false;
-    }
-    if (!Object.prototype.hasOwnProperty.call(normalized, 'controller')) {
-      normalized.controller = false;
-    }
-  }
-
-  return normalized;
-}
-
-/**
- * Validate required options for non-interactive external creation
- * @param {Object} normalizedOptions - Normalized options
- * @throws {Error} If required options are missing
- */
-function validateNonInteractiveExternalOptions(normalizedOptions) {
-  const missing = [];
-  if (!normalizedOptions.systemDisplayName) missing.push('--display-name');
-  if (!normalizedOptions.systemDescription) missing.push('--description');
-  if (!normalizedOptions.systemType) missing.push('--system-type');
-  if (!normalizedOptions.authType) missing.push('--auth-type');
-  if (!normalizedOptions.entityType) missing.push('--entity-type');
-  if (!normalizedOptions.datasourceCount) missing.push('--datasources');
-  if (missing.length > 0) {
-    throw new Error(`Missing required options for non-interactive external create: ${missing.join(', ')}`);
-  }
-  if (!Object.prototype.hasOwnProperty.call(normalizedOptions, 'github')) {
-    normalizedOptions.github = false;
-  }
-  if (!Object.prototype.hasOwnProperty.call(normalizedOptions, 'controller')) {
-    normalizedOptions.controller = false;
-  }
-}
-
 /**
  * Handle create command execution
  * @async
@@ -419,21 +323,7 @@ function setupDockerfileGenerateCommand(program) {
     });
 }
 
-function setupPushDeployDockerfileCommands(program) {
-  program.command('push <appKey>')
-    .description('Push builder appKey image to Azure Container Registry')
-    .addHelpText('after', PUSH_HELP_AFTER)
-    .option('-r, --registry <registry>', 'ACR registry URL (overrides application.yaml)')
-    .option('-t, --tag <tag>', 'Image tag(s) - comma-separated for multiple (default: latest)')
-    .action(async(appName, options) => {
-      try {
-        await app.pushApp(appName, options);
-      } catch (error) {
-        handleCommandError(error, 'push');
-        process.exit(1);
-      }
-    });
-
+function setupDeployCommand(program) {
   program.command('deploy <appKey|systemKey>')
     .description('Deploy builder app or external system via Miso Controller (Azure or --local)')
     .addHelpText('after', DEPLOY_HELP_AFTER)
@@ -441,13 +331,20 @@ function setupPushDeployDockerfileCommands(program) {
     .option('--client-id <id>', 'Client ID (overrides config)')
     .option('--client-secret <secret>', 'Client Secret (overrides config)')
     .option('--repository-url <url>', 'Repository URL for pipeline validation (default: application.yaml repository.repositoryUrl, else https://github.com/aifabrix/<appKey>)')
-    .option('--poll', 'Poll for deployment status', true)
-    .option('--no-poll', 'Do not poll for status')
+    .option('-v, --verbose', 'Expanded deploy summary and preflight progress')
     .option('--probe', 'After external deploy, run dataplane runtime checks (validation/run); slower')
     .option('--probe-timeout <ms>', 'Timeout for --probe on external deploy (default: 120000)', '120000')
     .option(
-      '--no-cert-sync',
-      'Skip updating integration certification in the system file from the dataplane after external deploy'
+      '--sync',
+      'After deploy, run full datasource data sync for every datasource on the system (default: bootstrap-if-empty only)'
+    )
+    .option(
+      '--gate <gates>',
+      'Optional pre-promote gates (comma-separated): operations, trust, governance, full'
+    )
+    .option(
+      '--subject-email <emails>',
+      'Subject email(s) for governance gate (comma-separated; used with --gate governance|full)'
     )
     .action(async(appName, options) => {
       try {
@@ -458,6 +355,7 @@ function setupPushDeployDockerfileCommands(program) {
         const opts = {
           ...options,
           local: !!options.local,
+          verbose: options.verbose === true,
           probeTimeout: Number.isFinite(probeTimeout) ? probeTimeout : 120000
         };
         const outcome = await app.deployApp(appName, opts);
@@ -470,7 +368,24 @@ function setupPushDeployDockerfileCommands(program) {
         process.exit(1);
       }
     });
+}
 
+function setupPushDeployDockerfileCommands(program) {
+  program.command('push <appKey>')
+    .description('Push builder appKey image to Azure Container Registry')
+    .addHelpText('after', PUSH_HELP_AFTER)
+    .option('-r, --registry <registry>', 'ACR registry URL (overrides application.yaml)')
+    .option('-t, --tag <tag>', 'Image tag(s) - comma-separated for multiple (default: latest)')
+    .action(async(appName, options) => {
+      try {
+        await app.pushApp(appName, options);
+      } catch (error) {
+        handleCommandError(error, 'push');
+        process.exit(1);
+      }
+    });
+
+  setupDeployCommand(program);
   setupDockerfileGenerateCommand(program);
 }
 
@@ -489,7 +404,5 @@ function setupAppCommands(program) {
 
 module.exports = {
   setupAppCommands,
-  normalizeExternalOptions,
-  prepareExternalCreateOptions,
-  validateNonInteractiveExternalOptions
+  ...require('./setup-app-external-create')
 };