@aifabrix/builder 2.49.2 → 2.50.0

package/lib/cli/setup-utility-repair.js

@@ -34,7 +34,11 @@ function buildRepairExternalIntegrationOptions(appName, options, format) {
     api: options.api || all,
     test: options.test || all,
     backup: options.backup,
-    noBackup: options.noBackup
+    noBackup: options.noBackup,
+    splitDatasources: options.splitDatasources === true,
+    rbacPreset: options.rbacPreset,
+    authWebhook: options.authWebhook === true,
+    authSync: options.authSync === true
   };
 }
 
@@ -142,7 +146,7 @@ function logRepairResult(options, result) {
  */
 async function handleRepairCommand(appName, options) {
   const { repairExternalIntegration } = require('../commands/repair');
-  const { appPath } = await detectAppType(appName);
+  const { appPath } = await detectAppType(appName, {});
   logOfflinePathWhenType(appPath);
   let format = 'yaml';
   try {
@@ -151,10 +155,9 @@ async function handleRepairCommand(appName, options) {
   } catch (_) {
     /* default yaml when config unavailable */
   }
-  const result = await repairExternalIntegration(
-    appName,
-    buildRepairExternalIntegrationOptions(appName, options, format)
-  );
+  const result = await repairExternalIntegration(appName, {
+    ...buildRepairExternalIntegrationOptions(appName, options, format)
+  });
   logRepairResult(options, result);
 }
 
@@ -175,9 +178,25 @@ function setupRepairCommand(program) {
     )
     .option('--doc', 'Regenerate README.md from deployment manifest')
     .option('--expose', 'Set exposed.schema on each datasource from all fieldMappings.attributes keys (metadata.<key>); removes deprecated exposed.attributes if present')
-    .option('--rbac', 'Ensure RBAC permissions per datasource and add default Admin/Reader roles if none exist')
+    .option('--rbac', 'Ensure RBAC permissions per datasource and add default Admin/Reader roles if none exist; warns when capabilities lack openapi.operations (auto-syncs operations)')
     .option('--sync', 'Add default sync section to datasources that lack it')
+    .option(
+      '--auth-webhook',
+      'Ensure authentications[] slot usage=webhookInbound (454 webhook inbound auth)'
+    )
+    .option(
+      '--auth-sync',
+      'Ensure authentications[] slot usage=syncExecution (454 syncBridge propagation auth)'
+    )
     .option('--test', 'Generate testPayload.payloadTemplate and testPayload.expectedResult from attributes')
+    .option(
+      '--split-datasources',
+      'Split monolithic *-datasource-operations into per-OpenAPI-tag datasources (orchestration-api)'
+    )
+    .option(
+      '--rbac-preset <preset>',
+      'RBAC preset for facade APIs (e.g. platform — dataplane role catalog)'
+    )
     .option('--no-backup', 'Skip timestamped copies under integration/<systemKey>/backup/')
     .option('--dry-run', 'Report changes only; do not write')
     .addHelpText('after', REPAIR_HELP_AFTER)

package/lib/cli/setup-utility.js

@@ -96,7 +96,7 @@ function setupJsonCommand(program) {
     .addHelpText('after', JSON_HELP_AFTER)
     .action(async(appName, options) => {
       try {
-        const resolved = await getResolveAppPath(appName);
+        const resolved = await getResolveAppPath(appName, {});
         const { emitManifestMetadataLineIfTTY } = require('../utils/manifest-source-emit');
         emitManifestMetadataLineIfTTY(logger, {
           appKey: appName,
@@ -104,7 +104,9 @@ function setupJsonCommand(program) {
           envOnly: resolved.envOnly,
           json: false
         });
-        const result = await generator.generateDeployJsonWithValidation(appName, options);
+        const result = await generator.generateDeployJsonWithValidation(appName, {
+          ...options
+        });
         if (result.success) {
           const fileName = result.path.includes('application-schema.json') ? 'application-schema.json' : 'deployment JSON';
           logger.log(`✔ Generated ${fileName}: ${result.path}`);
@@ -195,7 +197,7 @@ function setupConvertCommand(program) {
 
 function setupShowCommand(program) {
   program.command('show <appKey|systemKey>')
-    .description('Show builder app or external system from local tree (default) or controller (--online)')
+    .description('Show builder app or connected system from local tree (default) or online (--online)')
     .option('--online', 'Fetch application data from the controller')
     .option('--json', 'Output as JSON')
     .option(

package/lib/commands/app.js

@@ -17,17 +17,17 @@ const { registerApplication } = require('../app/register');
 const { rotateSecret } = require('../app/rotate-secret');
 const { showApp } = require('../app/show');
 const { runAppDeploymentList } = require('./deployment-list');
-const { isChannelTargetKey } = require('../channels/channel-targets');
-const { addChannelCommand } = require('../channels/add-channel');
+const { registerChannelAddCommand } = require('./channel-add-setup');
 
 const APP_HELP_AFTER = `
 Subcommands:
   register <appKey>     Register app; get pipeline client id/secret
-  list                  Applications in current environment
+  list                  Controller applications only (not connected systems)
   rotate-secret <key>   New ClientSecret (shown once)
-  show <key>            From controller (like show --online)
+  show <key>            Controller application details (pipeline apps only)
   deployment <key>      Deployment history for app
-  add-channel <target>  Configure assistant channel install (after deploy)
+
+Connected systems and channels: aifabrix list · aifabrix channel · aifabrix show <systemKey> --online
 
 Requires: aifabrix login
 `;
@@ -51,7 +51,7 @@ function setupAppRegisterCommand(app) {
 
 function setupAppListCommand(app) {
   app.command('list')
-    .description('List apps in current environment')
+    .description('List controller applications (excludes connected systems)')
     .action(async(options) => {
       try {
         await listApplications(options);
@@ -91,7 +91,8 @@ function setupAppShowCommand(app) {
           online: true,
           json: !!options.json,
           permissions: !!options.permissions,
-          verifyCert: options.verifyCert === true
+          verifyCert: options.verifyCert === true,
+          appsOnly: true
         });
       } catch (error) {
         logger.error(chalk.red(`Error: ${error.message}`));
@@ -121,41 +122,12 @@ function setupAppDeploymentCommand(app) {
     });
 }
 
-function setupAppAddChannelCommand(app) {
-  app.command('add-channel <channelTarget>')
-    .description(
-      'Configure assistant channel install (teams-bot, slack, …) after aifabrix deploy <target>'
-    )
-    .requiredOption('-n, --name <name>', 'Customer-visible channel name')
-    .option('-d, --description <text>', 'Channel description (default generated)')
-    .option('--icon <path>', 'Path to channel icon asset')
-    .option('--template <name>', 'Template override (default from channel target)')
-    .option('--dry-run', 'Generate artifacts only; do not patch external system or credentials')
-    .option('--force', 'Regenerate artifacts and patch config (does not rotate secrets)')
-    .option('--probe', 'After install, validate callbacks and assistant catalog')
-    .action(async(channelTarget, options) => {
-      try {
-        if (!isChannelTargetKey(channelTarget)) {
-          throw new Error(
-            `Unknown channel target "${channelTarget}". Use teams-bot, slack, microsoft-copilot, or chatgpt.`
-          );
-        }
-        await addChannelCommand(channelTarget, {
-          name: options.name,
-          description: options.description,
-          icon: options.icon,
-          template: options.template,
-          dryRun: options.dryRun === true,
-          force: options.force === true,
-          probe: options.probe === true
-        });
-      } catch (error) {
-        if (!error.message?.includes('Authentication required')) {
-          logger.error(formatBlockingError('Channel install failed:'), error.message);
-        }
-        process.exit(1);
-      }
-    });
+function setupAppDeprecatedAddChannelAlias(app) {
+  registerChannelAddCommand(app, {
+    commandName: 'add-channel <channelTarget>',
+    hidden: true,
+    deprecatedVia: 'aifabrix app add-channel'
+  });
 }
 
 /**
@@ -169,7 +141,7 @@ function setupAppCommands(program) {
   setupAppRotateSecretCommand(app);
   setupAppShowCommand(app);
   setupAppDeploymentCommand(app);
-  setupAppAddChannelCommand(app);
+  setupAppDeprecatedAddChannelAlias(app);
 }
 
 module.exports = { setupAppCommands };

package/lib/commands/channel-add-setup.js

@@ -0,0 +1,110 @@
+/**
+ * Register `channel add` (and optional deprecated aliases).
+ *
+ * @fileoverview Shared Commander wiring for assistant channel install (plan 152)
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { formatBlockingError } = require('../utils/cli-test-layout-chalk');
+const { isChannelTargetKey } = require('../channels/channel-targets');
+const { addChannelCommand } = require('../channels/add-channel');
+
+const CHANNEL_ADD_HELP_AFTER = `
+
+Examples:
+  # After upload/deploy of the communication external system
+  $ aifabrix channel add slack --name "Elsa"
+  $ aifabrix channel add teams-bot --name "Elsa" --description "Enterprise AI assistant for employees"
+
+  # Slack slash-command prefix (registers /{prefix}-help in manifest)
+  $ aifabrix channel add slack --name "Elsa" --command-prefix af
+
+  # Generate artifacts only; no dataplane patch
+  $ aifabrix channel add slack --name "Elsa" --dry-run
+
+  # Regenerate artifacts and patch config (does not rotate secrets)
+  $ aifabrix channel add slack --name "Elsa" --force
+
+  # Validate callbacks and assistant catalog after install
+  $ aifabrix channel add slack --name "Elsa" --probe
+
+Prerequisites: aifabrix upload <target> (or deploy) and aifabrix login
+`;
+
+/**
+ * @param {string} channelTarget
+ * @param {Object} options
+ * @param {{ deprecatedVia?: string }} [meta]
+ */
+async function runChannelAddAction(channelTarget, options, meta = {}) {
+  if (meta.deprecatedVia) {
+    logger.warn(
+      chalk.yellow(
+        `Deprecated: use "aifabrix channel add ${channelTarget} ..." instead of "${meta.deprecatedVia}".`
+      )
+    );
+  }
+  if (!isChannelTargetKey(channelTarget)) {
+    throw new Error(
+      `Unknown channel target "${channelTarget}". Use teams-bot, slack, microsoft-copilot, or chatgpt.`
+    );
+  }
+  await addChannelCommand(channelTarget, {
+    name: options.name,
+    description: options.description,
+    icon: options.icon,
+    template: options.template,
+    commandPrefix: options.commandPrefix,
+    dryRun: options.dryRun === true,
+    force: options.force === true,
+    probe: options.probe === true
+  });
+}
+
+/**
+ * @param {import('commander').Command} parent
+ * @param {{ deprecatedVia?: string, commandName?: string, hidden?: boolean }} [meta]
+ * @returns {import('commander').Command}
+ */
+function registerChannelAddCommand(parent, meta = {}) {
+  const description =
+    'Configure channel install (manifest, credentials, admin guide) after upload/deploy';
+  const commandName = meta.commandName || 'add <channelTarget>';
+  const cmd = meta.hidden
+    ? parent.command(commandName, { hidden: true })
+    : parent.command(commandName);
+  cmd
+    .description(meta.deprecatedVia ? `(deprecated) ${description}` : description)
+    .requiredOption('-n, --name <name>', 'Customer-visible channel name (e.g. "Elsa")')
+    .option('-d, --description <text>', 'Channel description (default generated)')
+    .option('--icon <path>', 'Path to channel icon asset')
+    .option('--template <name>', 'Template override (default from channel target)')
+    .option('--dry-run', 'Generate artifacts only; do not patch external system or credentials')
+    .option('--force', 'Regenerate artifacts and patch config (does not rotate secrets)')
+    .option(
+      '--command-prefix <key>',
+      'Slack slash alias prefix (default af) — registers /{prefix}-help etc. in manifest'
+    )
+    .option('--probe', 'After install, validate callbacks and assistant catalog')
+    .addHelpText('after', CHANNEL_ADD_HELP_AFTER)
+    .action(async(channelTarget, options) => {
+      try {
+        await runChannelAddAction(channelTarget, options, meta);
+      } catch (error) {
+        if (!error.message?.includes('Authentication required')) {
+          logger.error(formatBlockingError('Channel install failed:'), error.message);
+        }
+        process.exit(1);
+      }
+    });
+  return cmd;
+}
+
+module.exports = {
+  CHANNEL_ADD_HELP_AFTER,
+  registerChannelAddCommand,
+  runChannelAddAction
+};

package/lib/commands/channel.js

@@ -1,18 +1,43 @@
 /**
  * Channel CLI commands (plan 152).
  *
- * @fileoverview Scaffold communication external systems for channel deploy step 1
+ * @fileoverview Scaffold and install assistant communication channels (Slack, Teams, …)
  * @author AI Fabrix Team
- * @version 1.0.0
+ * @version 1.1.0
  */
 
 'use strict';
 
 const chalk = require('chalk');
 const logger = require('../utils/logger');
-const { formatSuccessLine, formatBlockingError, sectionTitle, metadata } = require('../utils/cli-test-layout-chalk');
+const {
+  formatSuccessLine,
+  formatBlockingError,
+  sectionTitle,
+  metadata
+} = require('../utils/cli-test-layout-chalk');
 const { CHANNEL_TARGET_KEYS, isChannelTargetKey } = require('../channels/channel-targets');
 const { scaffoldChannelIntegration } = require('../channels/channel-integration-generator');
+const { registerChannelAddCommand } = require('./channel-add-setup');
+
+const CHANNEL_HELP_AFTER = `
+Subcommands:
+  scaffold <target>   Create integration/<target>/ files locally (step 1)
+  add <target>        Channel install guide + manifest/credential patch (step 3)
+
+Targets:
+  teams-bot, slack, microsoft-copilot, chatgpt
+  web-embed (experimental — scaffold with --allow-experimental)
+
+Typical flow (channels are connected systems, not controller apps):
+  aifabrix channel scaffold slack
+  aifabrix upload slack --force
+  aifabrix channel add slack --name "Elsa" --probe
+
+Controller pipeline apps only: aifabrix app register · aifabrix app list
+
+Requires: aifabrix login (for add)
+`;
 
 /**
  * @param {import('commander').Command} program
@@ -20,11 +45,16 @@ const { scaffoldChannelIntegration } = require('../channels/channel-integration-
 function setupChannelCommands(program) {
   const channel = program
     .command('channel')
-    .description('Assistant channel integration scaffolds (plan 152)');
+    .description(
+      'Assistant channels (Slack, Teams, Copilot, ChatGPT) — scaffold integration and install'
+    )
+    .addHelpText('after', CHANNEL_HELP_AFTER);
 
   channel
     .command('scaffold <channelTarget>')
-    .description('Generate integration/<target>/ communication external system for deploy step 1')
+    .description(
+      'Generate integration/<target>/ communication external system (local files only)'
+    )
     .option('--force', 'Overwrite generated scaffold files when folder exists')
     .option('--allow-experimental', 'Allow web-embed scaffold')
     .action(async(channelTarget, options) => {
@@ -34,7 +64,7 @@ function setupChannelCommands(program) {
             `Unknown channel target "${channelTarget}". Expected: ${CHANNEL_TARGET_KEYS.join(', ')}`
           );
         }
-        const result = scaffoldChannelIntegration(channelTarget, {
+        const result = await scaffoldChannelIntegration(channelTarget, {
           force: options.force === true,
           allowExperimental: options.allowExperimental === true
         });
@@ -46,13 +76,17 @@ function setupChannelCommands(program) {
         }
         logger.log('');
         logger.log(chalk.white('Next steps:'));
-        logger.log(chalk.gray(`  aifabrix deploy ${channelTarget}`));
-        logger.log(chalk.gray(`  aifabrix app add-channel ${channelTarget} --name "Your Assistant"`));
+        logger.log(chalk.gray(`  aifabrix upload ${channelTarget} --force`));
+        logger.log(
+          chalk.gray(`  aifabrix channel add ${channelTarget} --name "Your Assistant" --probe`)
+        );
       } catch (error) {
         logger.error(formatBlockingError(error.message || String(error)));
         process.exit(1);
       }
     });
+
+  registerChannelAddCommand(channel);
 }
 
 module.exports = { setupChannelCommands };

package/lib/commands/datasource-sync-display.js

@@ -0,0 +1,96 @@
+/**
+ * @fileoverview TTY/JSON output for post-publish datasource data sync.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const logger = require('../utils/logger');
+const {
+  formatProgress,
+  formatSuccessLine,
+  formatWarningLine,
+  infoLine,
+  metadata
+} = require('../utils/cli-test-layout-chalk');
+
+const SKIP_REASON_LABELS = {
+  has_data: 'records already present',
+  no_connectivity: 'datasource not available on dataplane',
+  skipped: 'sync disabled'
+};
+
+/**
+ * @param {Object|null|undefined} result
+ * @param {Object} [options]
+ * @param {boolean} [options.syncExplicit]
+ * @returns {boolean}
+ */
+function shouldEmitDatasourceSyncSummary(result, options = {}) {
+  if (!result || options.json === true) {
+    return false;
+  }
+  // Default upload/deploy: bootstrap may run, but output only when user passed --sync.
+  if (options.syncExplicit !== true) {
+    return false;
+  }
+  const executed = result.executed || [];
+  const skipped = result.skipped || [];
+  return executed.length > 0 || skipped.length > 0;
+}
+
+/**
+ * @param {Object} row
+ * @returns {string}
+ */
+function formatSkippedSyncLine(row) {
+  const detail = SKIP_REASON_LABELS[row.reason] || row.reason;
+  if (row.reason === 'has_data') {
+    return metadata(`  ${row.datasourceKey}: ${detail} (bootstrap not needed)`);
+  }
+  return formatWarningLine(`  Skipped ${row.datasourceKey}: ${detail}`);
+}
+
+/**
+ * @param {Object} result
+ * @param {Object} [options]
+ * @param {boolean} [options.json]
+ * @param {boolean} [options.syncExplicit]
+ * @param {string} [options.label]
+ */
+function logDatasourceSyncSummary(result, options = {}) {
+  if (!shouldEmitDatasourceSyncSummary(result, options)) {
+    return;
+  }
+  const label = options.label || 'Data sync';
+  logger.log('');
+  logger.log(infoLine(label));
+  for (const row of result.skipped || []) {
+    if (!options.syncExplicit && row.reason === 'has_data') {
+      continue;
+    }
+    logger.log(formatSkippedSyncLine(row));
+  }
+  for (const row of result.executed || []) {
+    if (row.syncJobId) {
+      logger.log(
+        formatSuccessLine(
+          `  Synced ${row.datasourceKey} (${row.reason}; syncJobId ${row.syncJobId})`
+        )
+      );
+      continue;
+    }
+    const warn = row.warning ? ` — ${row.warning}` : '';
+    logger.log(formatWarningLine(`  Sync failed ${row.datasourceKey}${warn}`));
+  }
+  if ((result.executed || []).length === 0 && (result.skipped || []).length === 0) {
+    logger.log(formatProgress('  No datasource keys to evaluate.'));
+  }
+}
+
+module.exports = {
+  logDatasourceSyncSummary,
+  shouldEmitDatasourceSyncSummary,
+  SKIP_REASON_LABELS
+};