@aifabrix/builder 2.45.5 → 2.47.0

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

@@ -0,0 +1,197 @@
+/**
+ * `aifabrix validate` and `diff` command wiring (split from setup-utility for size limits).
+ *
+ * @fileoverview Validate and diff CLI commands
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { handleCommandError } = require('../utils/cli-utils');
+const { VALIDATE_HELP_AFTER } = require('./setup-utility-help-after');
+
+/**
+ * @param {string} appOrFile
+ * @param {object} result
+ * @param {string} outFormat
+ */
+function emitManifestAfterValidateIfApplicable(appOrFile, result, outFormat) {
+  if (outFormat === 'json' || !result?.appPath || !appOrFile || typeof appOrFile !== 'string') {
+    return;
+  }
+  try {
+    if (fs.existsSync(appOrFile) && fs.statSync(appOrFile).isFile()) {
+      return;
+    }
+    const { emitManifestMetadataLineIfTTY } = require('../utils/manifest-source-emit');
+    emitManifestMetadataLineIfTTY(logger, {
+      appKey: appOrFile,
+      appPath: result.appPath,
+      envOnly: false,
+      json: false
+    });
+  } catch {
+    /* ignore emit failures */
+  }
+}
+
+/**
+ * @param {object} validate
+ * @param {object} opts
+ * @returns {Promise<boolean>}
+ */
+async function runValidateBatchBranch(validate, opts) {
+  const integration = opts.integration === true;
+  const builder = opts.builder === true;
+  if (!integration && !builder) {
+    return false;
+  }
+  const outFormat = (opts.format || 'default').toLowerCase();
+  const batchResult = integration && builder
+    ? await validate.validateAll(opts)
+    : integration
+      ? await validate.validateAllIntegrations(opts)
+      : await validate.validateAllBuilderApps(opts);
+  if (outFormat === 'json') {
+    logger.log(JSON.stringify(batchResult, null, 2));
+  } else {
+    validate.displayBatchValidationResults(batchResult);
+  }
+  if (!batchResult.valid) process.exit(1);
+  return true;
+}
+
+/**
+ * @param {string} appOrFile
+ * @param {object} opts
+ * @returns {Promise<void>}
+ */
+async function runProtectionValidateBranch(appOrFile, opts) {
+  const { validateProtectionBatchCommand } = require('../protection/validate-batch');
+  const code = await validateProtectionBatchCommand(
+    {
+      env: opts.env,
+      json: (opts.format || '').toLowerCase() === 'json',
+      warningsAsErrors: opts.warningsAsErrors === true,
+      simulate: opts.simulate === true,
+      verbose: opts.verbose === true
+    },
+    logger
+  );
+  if (code !== 0) {
+    process.exit(code);
+  }
+}
+
+/**
+ * @param {object} result
+ * @param {string} appOrFile
+ * @returns {object}
+ */
+function buildValidateJsonPayload(result, appOrFile) {
+  let payload = result;
+  try {
+    if (result?.appPath && appOrFile && typeof appOrFile === 'string') {
+      if (!(fs.existsSync(appOrFile) && fs.statSync(appOrFile).isFile())) {
+        const { getManifestSourcePayload } = require('../utils/manifest-source-emit');
+        payload = { ...result, manifestSource: getManifestSourcePayload(appOrFile, result.appPath) };
+      }
+    }
+  } catch {
+    /* keep plain result */
+  }
+  return payload;
+}
+
+/**
+ * @param {string} appOrFile
+ * @param {object} result
+ * @param {string} outFormat
+ * @param {object} validate
+ */
+function displaySingleValidateResult(appOrFile, result, outFormat, validate) {
+  emitManifestAfterValidateIfApplicable(appOrFile, result, outFormat);
+  if (outFormat === 'json') {
+    logger.log(JSON.stringify(buildValidateJsonPayload(result, appOrFile), null, 2));
+    return;
+  }
+  validate.displayValidationResults(result);
+}
+
+/**
+ * @param {string} appOrFile
+ * @param {object} options
+ * @returns {Promise<void>}
+ */
+async function runValidateCommand(appOrFile, options) {
+  const validate = require('../validation/validate');
+  const opts = options.opts ? options.opts() : options;
+  const { isProtectionScope } = require('../protection/scope');
+  if (isProtectionScope(appOrFile)) {
+    await runProtectionValidateBranch(appOrFile, opts);
+    return;
+  }
+  if (await runValidateBatchBranch(validate, opts)) {
+    return;
+  }
+  const outFormat = (opts.format || 'default').toLowerCase();
+  if (!appOrFile || typeof appOrFile !== 'string') {
+    logger.log(chalk.red('App name or file path is required, or use --integration / --builder'));
+    process.exit(1);
+  }
+  const result = await validate.validateAppOrFile(appOrFile, {
+    ...opts,
+    certSync: opts.certSync === true
+  });
+  displaySingleValidateResult(appOrFile, result, outFormat, validate);
+  if (!result.valid) process.exit(1);
+}
+
+/**
+ * @param {import('commander').Command} program
+ */
+function setupValidateDiffCommands(program) {
+  program.command('validate [appKey|systemKey|file]')
+    .description('Validate appKey, systemKey, file path, .protection batch, or all under integration/ and builder/')
+    .addHelpText('after', VALIDATE_HELP_AFTER)
+    .option('--format <format>', 'Output format: json | default (human-readable)')
+    .option('--integration', 'Validate all applications under integration/')
+    .option('--builder', 'Validate all applications under builder/')
+    .option('--warnings-as-errors', 'For .protection: pass strict=true to dataplane validate')
+    .option('--simulate', 'For .protection: run simulate after validate')
+    .option(
+      '--cert-sync',
+      'After successful validation of an external integration, refresh the system file certification block from the dataplane (requires login)'
+    )
+    .action((appOrFile, options) => {
+      runValidateCommand(appOrFile, options).catch((error) => {
+        handleCommandError(error, 'validate');
+        process.exit(1);
+      });
+    });
+
+  program.command('diff <file1> <file2>')
+    .description('Diff two config files (optional schema validate)')
+    .option('--no-validate', 'Skip schema validation (type check still applied)')
+    .action(async(file1, file2, cmd) => {
+      try {
+        const diff = require('../core/diff');
+        const opts = cmd.opts();
+        const result = await diff.compareFiles(file1, file2, { validate: opts.validate !== false });
+        diff.formatDiffOutput(result);
+        if (!result.identical) process.exit(1);
+      } catch (error) {
+        handleCommandError(error, 'diff');
+        process.exit(1);
+      }
+    });
+}
+
+module.exports = {
+  setupValidateDiffCommands,
+  runValidateCommand
+};

package/lib/cli/setup-utility.js

@@ -1,4 +1,3 @@
-const { formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
 /**
  * CLI utility command setup (resolve, json, split-json, show, validate, diff).
  *
@@ -10,12 +9,15 @@ const { formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
 const path = require('path');
 const fs = require('fs');
 const chalk = require('chalk');
+const { formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
 const generator = require('../generator');
 const logger = require('../utils/logger');
 const { handleCommandError, logOfflinePathWhenType } = require('../utils/cli-utils');
 const { detectAppType, getDeployJsonPath, getResolveAppPath } = require('../utils/paths');
 const { setupResolveCommand } = require('./setup-utility-resolve');
-const { JSON_HELP_AFTER, VALIDATE_HELP_AFTER, REPAIR_HELP_AFTER } = require('./setup-utility-help-after');
+const { setupRepairCommand } = require('./setup-utility-repair');
+const { setupValidateDiffCommands } = require('./setup-utility-validate');
+const { JSON_HELP_AFTER } = require('./setup-utility-help-after');
 
 /**
  * Resolve app path and type for split-json (integration first, then builder).
@@ -136,100 +138,6 @@ function setupSplitJsonCommand(program) {
     });
 }
 
-function buildRepairExternalIntegrationOptions(appName, options, format) {
-  const all = options.all === true;
-  return {
-    auth: options.auth,
-    doc: options.doc || all,
-    dryRun: options.dryRun,
-    format,
-    rbac: options.rbac || all,
-    expose: options.expose || all,
-    sync: options.sync || all,
-    api: options.api || all,
-    test: options.test || all,
-    backup: options.backup,
-    noBackup: options.noBackup
-  };
-}
-
-function logRepairResult(options, result) {
-  if (options.dryRun && result.updated && result.changes.length > 0) {
-    logger.log(chalk.yellow('\nWould apply:'));
-    result.changes.forEach(c => logger.log(chalk.gray(`  ${c}`)));
-    return;
-  }
-  if (Array.isArray(result.backupPaths) && result.backupPaths.length > 0) {
-    result.backupPaths.forEach((p) => logger.log(chalk.gray(`Backup: ${p}`)));
-  }
-  if (result.updated) {
-    logger.log(formatSuccessParagraph('Repaired external integration config.'));
-    return;
-  }
-  if (Array.isArray(result.changes) && result.changes.length > 0) {
-    logger.log(formatSuccessParagraph('Repair actions completed.'));
-    result.changes.forEach(c => logger.log(chalk.gray(`  ${c}`)));
-    return;
-  }
-  if (result.readmeRegenerated) {
-    logger.log(formatSuccessParagraph('Regenerated README.md from deployment manifest.'));
-    return;
-  }
-  logger.log(chalk.gray('No changes needed; config already matches files on disk.'));
-}
-
-/**
- * Handler for `aifabrix repair <systemKey>`.
- * @param {string} appName
- * @param {object} options - Commander options
- * @returns {Promise<void>}
- */
-async function handleRepairCommand(appName, options) {
-  const { repairExternalIntegration } = require('../commands/repair');
-  const { detectAppType } = require('../utils/paths');
-  const { appPath } = await detectAppType(appName);
-  logOfflinePathWhenType(appPath);
-  let format = 'yaml';
-  try {
-    const config = require('../core/config');
-    format = (await config.getFormat()) || format;
-  } catch (_) {
-    /* default yaml when config unavailable */
-  }
-  const result = await repairExternalIntegration(
-    appName,
-    buildRepairExternalIntegrationOptions(appName, options, format)
-  );
-  logRepairResult(options, result);
-}
-
-function setupRepairCommand(program) {
-  program.command('repair <systemKey>')
-    .description('Fix external integration drift (files, RBAC, manifest, …)')
-    .option('--all', 'Run all repair actions (api, doc, expose, rbac, sync, test)')
-    .option(
-      '--api',
-      'Validate and sync API contracts needed for OpenAPI/MCP (uses local OpenAPI specs at integration/<systemKey>/openapi/*.json when present)'
-    )
-    .option('--auth <method>', 'Set authentication method (oauth2, aad, apikey, basic, queryParam, oidc, hmac, none); updates system file and env.template')
-    .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('--sync', 'Add default sync section to datasources that lack it')
-    .option('--test', 'Generate testPayload.payloadTemplate and testPayload.expectedResult from attributes')
-    .option('--no-backup', 'Skip timestamped copies under integration/<systemKey>/backup/')
-    .option('--dry-run', 'Report changes only; do not write')
-    .addHelpText('after', REPAIR_HELP_AFTER)
-    .action(async(appName, options) => {
-      try {
-        await handleRepairCommand(appName, options);
-      } catch (error) {
-        handleCommandError(error, 'repair');
-        process.exit(1);
-      }
-    });
-}
-
 async function resolveConvertTargetFormat(options) {
   const config = require('../core/config');
   const effectiveFormat = options.format || (await config.getFormat());
@@ -316,149 +224,6 @@ function setupSplitJsonConvertShowCommands(program) {
   setupShowCommand(program);
 }
 
-function emitManifestAfterValidateIfApplicable(appOrFile, result, outFormat) {
-  if (outFormat === 'json' || !result?.appPath || !appOrFile || typeof appOrFile !== 'string') {
-    return;
-  }
-  try {
-    if (fs.existsSync(appOrFile) && fs.statSync(appOrFile).isFile()) {
-      return;
-    }
-    const { emitManifestMetadataLineIfTTY } = require('../utils/manifest-source-emit');
-    emitManifestMetadataLineIfTTY(logger, {
-      appKey: appOrFile,
-      appPath: result.appPath,
-      envOnly: false,
-      json: false
-    });
-  } catch {
-    /* ignore emit failures */
-  }
-}
-
-async function runValidateBatchBranch(validate, opts) {
-  const integration = opts.integration === true;
-  const builder = opts.builder === true;
-  if (!integration && !builder) {
-    return false;
-  }
-  const outFormat = (opts.format || 'default').toLowerCase();
-  const batchResult = integration && builder
-    ? await validate.validateAll(opts)
-    : integration
-      ? await validate.validateAllIntegrations(opts)
-      : await validate.validateAllBuilderApps(opts);
-  if (outFormat === 'json') {
-    logger.log(JSON.stringify(batchResult, null, 2));
-  } else {
-    validate.displayBatchValidationResults(batchResult);
-  }
-  if (!batchResult.valid) process.exit(1);
-  return true;
-}
-
-async function runProtectionValidateBranch(appOrFile, opts) {
-  const { validateProtectionBatchCommand } = require('../protection/validate-batch');
-  const code = await validateProtectionBatchCommand(
-    {
-      env: opts.env,
-      json: (opts.format || '').toLowerCase() === 'json',
-      warningsAsErrors: opts.warningsAsErrors === true,
-      simulate: opts.simulate === true,
-      verbose: opts.verbose === true
-    },
-    logger
-  );
-  if (code !== 0) {
-    process.exit(code);
-  }
-}
-
-function buildValidateJsonPayload(result, appOrFile) {
-  let payload = result;
-  try {
-    if (result?.appPath && appOrFile && typeof appOrFile === 'string') {
-      if (!(fs.existsSync(appOrFile) && fs.statSync(appOrFile).isFile())) {
-        const { getManifestSourcePayload } = require('../utils/manifest-source-emit');
-        payload = { ...result, manifestSource: getManifestSourcePayload(appOrFile, result.appPath) };
-      }
-    }
-  } catch {
-    /* keep plain result */
-  }
-  return payload;
-}
-
-function displaySingleValidateResult(appOrFile, result, outFormat, validate) {
-  emitManifestAfterValidateIfApplicable(appOrFile, result, outFormat);
-  if (outFormat === 'json') {
-    logger.log(JSON.stringify(buildValidateJsonPayload(result, appOrFile), null, 2));
-    return;
-  }
-  validate.displayValidationResults(result);
-}
-
-async function runValidateCommand(appOrFile, options) {
-  const validate = require('../validation/validate');
-  const opts = options.opts ? options.opts() : options;
-  const { isProtectionScope } = require('../protection/scope');
-  if (isProtectionScope(appOrFile)) {
-    await runProtectionValidateBranch(appOrFile, opts);
-    return;
-  }
-  if (await runValidateBatchBranch(validate, opts)) {
-    return;
-  }
-  const outFormat = (opts.format || 'default').toLowerCase();
-  if (!appOrFile || typeof appOrFile !== 'string') {
-    logger.log(chalk.red('App name or file path is required, or use --integration / --builder'));
-    process.exit(1);
-  }
-  const result = await validate.validateAppOrFile(appOrFile, {
-    ...opts,
-    certSync: opts.certSync === true
-  });
-  displaySingleValidateResult(appOrFile, result, outFormat, validate);
-  if (!result.valid) process.exit(1);
-}
-
-function setupValidateDiffCommands(program) {
-  program.command('validate [appKey|systemKey|file]')
-    .description('Validate appKey, systemKey, file path, .protection batch, or all under integration/ and builder/')
-    .addHelpText('after', VALIDATE_HELP_AFTER)
-    .option('--format <format>', 'Output format: json | default (human-readable)')
-    .option('--integration', 'Validate all applications under integration/')
-    .option('--builder', 'Validate all applications under builder/')
-    .option('--warnings-as-errors', 'For .protection: pass strict=true to dataplane validate')
-    .option('--simulate', 'For .protection: run simulate after validate')
-    .option(
-      '--cert-sync',
-      'After successful validation of an external integration, refresh the system file certification block from the dataplane (requires login)'
-    )
-    .action((appOrFile, options) => {
-      runValidateCommand(appOrFile, options).catch((error) => {
-        handleCommandError(error, 'validate');
-        process.exit(1);
-      });
-    });
-
-  program.command('diff <file1> <file2>')
-    .description('Diff two config files (optional schema validate)')
-    .option('--no-validate', 'Skip schema validation (type check still applied)')
-    .action(async(file1, file2, cmd) => {
-      try {
-        const diff = require('../core/diff');
-        const opts = cmd.opts();
-        const result = await diff.compareFiles(file1, file2, { validate: opts.validate !== false });
-        diff.formatDiffOutput(result);
-        if (!result.identical) process.exit(1);
-      } catch (error) {
-        handleCommandError(error, 'diff');
-        process.exit(1);
-      }
-    });
-}
-
 /**
  * Sets up utility commands
  * @param {Command} program - Commander program instance

package/lib/commands/app-logs.js

@@ -13,6 +13,10 @@ const logger = require('../utils/logger');
 const config = require('../core/config');
 const containerHelpers = require('../utils/app-run-containers');
 const { validateAppName } = require('../app/push');
+const {
+  getCeleryCompanionAppKeys,
+  loadBuilderApplicationConfig
+} = require('../utils/celery-companion-apps');
 
 const { execWithDockerEnv } = require('../utils/docker-exec');
 const { maskEnvLine } = require('../utils/log-redaction');
@@ -295,6 +299,36 @@ async function runDockerLogsFollow(containerName, tail, minLevel) {
   });
 }
 
+function parseLogLevelOption(options) {
+  const rawLevel =
+    options.level !== undefined && options.level !== null && options.level !== ''
+      ? String(options.level).trim()
+      : undefined;
+  const level = rawLevel ? rawLevel.toLowerCase() : undefined;
+  if (level !== undefined && level !== null && !LOG_LEVELS.includes(level)) {
+    throw new Error(
+      `Invalid log level '${rawLevel}'; use one of: ${LOG_LEVELS.join(', ')}`
+    );
+  }
+  return level;
+}
+
+async function logFollowStream(companionKeys, containerName, tail, level) {
+  await runDockerLogsFollow(containerName, tail, level);
+  if (companionKeys.length > 0) {
+    const hint = companionKeys.map((key) => `aifabrix logs ${key}`).join(' or ');
+    logger.log(chalk.gray(`Tip: sidecar logs — ${hint}`));
+  }
+}
+
+async function logContainerSnapshot(containerName, tail, level) {
+  try {
+    await runDockerLogs(containerName, { tail, level });
+  } catch (err) {
+    logger.log(chalk.yellow(`No logs for ${containerName}: ${err.message}`));
+  }
+}
+
 /**
  * Run app logs command: optional env dump (masked), then docker logs
  * @async
@@ -307,39 +341,33 @@ async function runDockerLogsFollow(containerName, tail, minLevel) {
  */
 async function runAppLogs(appKey, options = {}) {
   validateAppName(appKey);
-  const rawLevel =
-    options.level !== undefined && options.level !== null && options.level !== ''
-      ? String(options.level).trim()
-      : undefined;
-  const level = rawLevel ? rawLevel.toLowerCase() : undefined;
-  if (level !== undefined && level !== null && !LOG_LEVELS.includes(level)) {
-    throw new Error(
-      `Invalid log level '${rawLevel}'; use one of: ${LOG_LEVELS.join(', ')}`
-    );
-  }
-
+  const level = parseLogLevelOption(options);
   const developerId = await config.getDeveloperId();
-  const containerName = containerHelpers.getContainerName(appKey, developerId);
-
   const follow = !!options.follow;
   const tail = typeof options.tail === 'number' ? options.tail : DEFAULT_TAIL_LINES;
+  const appConfig = loadBuilderApplicationConfig(appKey);
+  const companionKeys = getCeleryCompanionAppKeys(appKey, appConfig);
+  const appKeysToLog = follow ? [appKey] : [appKey, ...companionKeys];
 
-  logger.log(chalk.blue(`Container: ${containerName}\n`));
+  for (const key of appKeysToLog) {
+    const containerName = containerHelpers.getContainerName(key, developerId);
 
-  if (!follow) {
-    await dumpMaskedEnv(containerName);
-  }
+    logger.log(chalk.blue(`Container: ${containerName}\n`));
 
-  if (follow) {
-    await runDockerLogsFollow(containerName, tail, level);
-    return;
-  }
+    if (!follow) {
+      await dumpMaskedEnv(containerName);
+    }
 
-  try {
-    await runDockerLogs(containerName, { tail, level });
-  } catch (err) {
-    logger.log(chalk.red(`Error: ${err.message}`));
-    throw new Error(`Failed to show logs: ${err.message}`);
+    if (follow) {
+      await logFollowStream(companionKeys, containerName, tail, level);
+      return;
+    }
+
+    await logContainerSnapshot(containerName, tail, level);
+
+    if (key !== appKeysToLog[appKeysToLog.length - 1]) {
+      logger.log('');
+    }
   }
 }
 

package/lib/commands/app.js

@@ -17,6 +17,8 @@ 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 APP_HELP_AFTER = `
 Subcommands:
@@ -25,6 +27,7 @@ Subcommands:
   rotate-secret <key>   New ClientSecret (shown once)
   show <key>            From controller (like show --online)
   deployment <key>      Deployment history for app
+  add-channel <target>  Configure assistant channel install (after deploy)
 
 Requires: aifabrix login
 `;
@@ -118,6 +121,43 @@ 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);
+      }
+    });
+}
+
 /**
  * Setup application management commands
  * @param {Command} program - Commander program instance
@@ -129,6 +169,7 @@ function setupAppCommands(program) {
   setupAppRotateSecretCommand(app);
   setupAppShowCommand(app);
   setupAppDeploymentCommand(app);
+  setupAppAddChannelCommand(app);
 }
 
 module.exports = { setupAppCommands };