@aifabrix/builder 2.53.1 → 2.54.1

package/lib/channels/channel-configuration-map.js

@@ -0,0 +1,213 @@
+/**
+ * Map ES configuration[] names to consumer propertyKeys and install options.
+ *
+ * @fileoverview CHANNEL_COMMAND_PREFIX → commandPrefix
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const SECRET_NAME_RE = /(SECRET|PASSWORD|TOKEN|KEY|CREDENTIAL)/i;
+
+/**
+ * @param {string} envName
+ * @returns {string}
+ */
+function envNameToPropertyKey(envName) {
+  const stripped = String(envName || '').replace(/^CHANNEL_/, '');
+  const lower = stripped.toLowerCase();
+  return lower.replace(/_([a-z0-9])/g, (_, ch) => ch.toUpperCase());
+}
+
+/**
+ * @param {Object} definition
+ * @returns {Object[]}
+ */
+function listDefinitionConfiguration(definition) {
+  const rows = definition && Array.isArray(definition.configuration) ? definition.configuration : [];
+  return rows.filter((row) => row && typeof row.name === 'string');
+}
+
+/**
+ * @param {Object} definition
+ * @returns {Map<string, Object>}
+ */
+function configurationByPropertyKey(definition) {
+  const map = new Map();
+  for (const row of listDefinitionConfiguration(definition)) {
+    map.set(envNameToPropertyKey(row.name), row);
+  }
+  return map;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+function isSecretShapedValue(value) {
+  if (typeof value !== 'string') {
+    return false;
+  }
+  return /kv:\/\//i.test(value) || SECRET_NAME_RE.test(value);
+}
+
+/**
+ * Safe configuration for GET definition (no secret-shaped values).
+ * @param {Object} definition
+ * @returns {Object[]}
+ */
+function toSafeConfiguration(definition) {
+  return listDefinitionConfiguration(definition).map((row) => {
+    const copy = { ...row };
+    if (isSecretShapedValue(copy.value)) {
+      copy.value = '';
+    }
+    copy.propertyKey = envNameToPropertyKey(row.name);
+    return copy;
+  });
+}
+
+/**
+ * @param {Object} row
+ * @returns {Object|null}
+ */
+function toPortalField(row) {
+  const portal = row && row.portalInput;
+  if (!portal || typeof portal !== 'object') {
+    return null;
+  }
+  if (typeof portal.label !== 'string' || !portal.label.trim()) {
+    return null;
+  }
+  if (isSecretShapedValue(row.value)) {
+    return null;
+  }
+  const propertyKey = envNameToPropertyKey(row.name);
+  const field = {
+    propertyKey,
+    label: portal.label.trim(),
+    required: row.required === true,
+    envName: row.name
+  };
+  if (portal.field) {
+    field.inputKind = portal.field;
+  }
+  if (portal.placeholder) {
+    field.placeholder = portal.placeholder;
+  }
+  if (Array.isArray(portal.options) && portal.options.length > 0) {
+    field.options = portal.options;
+  }
+  if (
+    typeof row.value === 'string' &&
+    row.value.trim() &&
+    !row.value.includes('{{') &&
+    !/kv:\/\//i.test(row.value)
+  ) {
+    field.defaultValue = row.value.trim();
+  }
+  assignPortalConstraints(field, portal.validation);
+  return field;
+}
+
+/**
+ * @param {Object} field
+ * @param {unknown} validation
+ */
+function assignPortalConstraints(field, validation) {
+  if (!validation || typeof validation !== 'object') {
+    return;
+  }
+  const rules = /** @type {Record<string, unknown>} */ (validation);
+  if (typeof rules.minLength === 'number' && rules.minLength > 0) {
+    field.minLength = rules.minLength;
+  }
+  if (typeof rules.maxLength === 'number' && rules.maxLength > 0) {
+    field.maxLength = rules.maxLength;
+  }
+  if (typeof rules.pattern === 'string' && rules.pattern.trim()) {
+    field.pattern = rules.pattern.trim();
+  }
+}
+
+/**
+ * Portal-facing fields only. Rows without portalInput are hidden system variables.
+ * @param {Object} definition
+ * @returns {Object[]}
+ */
+function toPortalFields(definition) {
+  return listDefinitionConfiguration(definition)
+    .map(toPortalField)
+    .filter(Boolean);
+}
+
+/**
+ * @param {Object} definition
+ * @param {Object} configuration
+ * @returns {string[]}
+ */
+function unknownConfigurationKeys(definition, configuration) {
+  if (!configuration || typeof configuration !== 'object') {
+    return [];
+  }
+  const known = configurationByPropertyKey(definition);
+  return Object.keys(configuration).filter((key) => !known.has(key));
+}
+
+/**
+ * @param {Object} definition
+ * @param {Object} configuration
+ * @returns {string[]}
+ */
+function missingRequiredConfigurationKeys(definition, configuration) {
+  const provided = configuration && typeof configuration === 'object' ? configuration : {};
+  const missing = [];
+  for (const [propertyKey, row] of configurationByPropertyKey(definition).entries()) {
+    if (row.required === true && (provided[propertyKey] === undefined || provided[propertyKey] === '')) {
+      missing.push(propertyKey);
+    }
+  }
+  return missing;
+}
+
+const OPTION_BY_PROPERTY_KEY = {
+  commandPrefix: 'commandPrefix',
+  packageVersion: 'packageVersion',
+  oauthPluginVaultReferenceId: 'oauthPluginVaultReferenceId',
+  appDescription: 'description'
+};
+
+/**
+ * @param {Object} options
+ * @param {Object} configuration
+ * @returns {Object}
+ */
+function applyConfigurationToAddOptions(options, configuration) {
+  if (!configuration || typeof configuration !== 'object') {
+    return options;
+  }
+  const next = { ...options };
+  for (const [propertyKey, value] of Object.entries(configuration)) {
+    if (SECRET_NAME_RE.test(propertyKey) && !OPTION_BY_PROPERTY_KEY[propertyKey]) {
+      continue;
+    }
+    const optionKey = OPTION_BY_PROPERTY_KEY[propertyKey] || propertyKey;
+    if (value !== undefined) {
+      next[optionKey] = value;
+    }
+  }
+  return next;
+}
+
+module.exports = {
+  envNameToPropertyKey,
+  listDefinitionConfiguration,
+  configurationByPropertyKey,
+  toSafeConfiguration,
+  toPortalFields,
+  unknownConfigurationKeys,
+  missingRequiredConfigurationKeys,
+  applyConfigurationToAddOptions,
+  isSecretShapedValue
+};

package/lib/channels/channel-credential.js

@@ -26,7 +26,8 @@ const CREDENTIAL_SPECS = {
     method: 'hmac',
     credentialConfig: {
       type: 'hmac',
-      signingSecret: 'pending-channel-install',
+      signingSecret: 'kv://slack/signingSecret',
+      botToken: 'kv://slack/botToken',
       algorithm: 'sha256',
       signatureHeader: 'X-Slack-Signature',
       timestampHeader: 'X-Slack-Request-Timestamp',
@@ -57,15 +58,6 @@ const CREDENTIAL_SPECS = {
       clientSecret: 'pending-channel-install'
     }
   },
-  chatgpt: {
-    method: 'apiKey',
-    credentialConfig: {
-      type: 'apiKey',
-      apiKey: 'pending-channel-install',
-      headerName: 'Authorization',
-      prefix: 'Bearer'
-    }
-  },
   'web-embed': {
     method: 'apiKey',
     credentialConfig: {
@@ -148,10 +140,15 @@ async function createChannelCredential(ctx, channelTarget, target) {
  * @returns {Promise<{ pushed: number }>}
  */
 async function pushIntegrationSecrets(ctx, channelTarget) {
-  const integrationDir = getIntegrationPath(channelTarget);
-  const envPath = path.join(integrationDir, '.env');
+  const folderKey =
+    ctx && typeof ctx.instanceSystemKey === 'string' && ctx.instanceSystemKey.trim()
+      ? ctx.instanceSystemKey.trim()
+      : channelTarget;
+  const integrationDir = ctx && ctx.projectRoot
+    ? path.join(path.resolve(ctx.projectRoot), 'integration', folderKey)
+    : getIntegrationPath(folderKey);
   const result = await pushCredentialSecrets(ctx.dataplaneUrl, ctx.authConfig, {
-    envFilePath: envPath,
+    envFilePath: path.join(integrationDir, '.env'),
     appName: channelTarget,
     quiet: true
   });
@@ -175,7 +172,7 @@ async function ensureChannelCredential(params) {
   if (skipsChannelOauthCredential(channelTarget)) {
     return {
       skipped: true,
-      reason: 'entraSsoTrustedIssuer',
+      reason: channelTarget === 'microsoft-copilot' ? 'entraSsoTrustedIssuer' : 'integrationClientOAuth',
       credentialKey: target.credentialKey
     };
   }

package/lib/channels/channel-definition-project.js

@@ -0,0 +1,101 @@
+/**
+ * Project Channel Definitions into the historic CHANNEL_TARGETS row shape.
+ *
+ * @fileoverview Catalog / wizard / adapter packaging from channel.json
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { definitionRuntimeSystemKey } = require('./channel-definition-registry');
+
+const DEFAULT_CAPABILITIES = ['chat', 'notify', 'documentApproval'];
+
+/**
+ * @param {Object} definition
+ * @returns {Object}
+ */
+function packagingOf(definition) {
+  const packing = definition && definition.channel && definition.channel.packaging;
+  return packing && typeof packing === 'object' ? packing : {};
+}
+
+/**
+ * @param {Object} definition
+ * @param {Object} packing
+ * @returns {string}
+ */
+function credentialKeyOf(definition, packing) {
+  const fromAuth =
+    definition.authentication && definition.authentication.credential
+      ? definition.authentication.credential.credentialKey
+      : null;
+  return fromAuth || packing.credentialKey || `${definition.key}-channel`;
+}
+
+/**
+ * @param {Object} definition
+ * @param {Object} channel
+ * @returns {Object}
+ */
+function runtimeTargetOf(definition, channel) {
+  return (
+    channel.runtimeTarget || {
+      defaultSystemKey: definitionRuntimeSystemKey(definition),
+      configurable: true
+    }
+  );
+}
+
+/**
+ * @param {Object} definition
+ * @param {Object} packing
+ * @returns {Object}
+ */
+function packagingFields(definition, packing) {
+  return {
+    channelType: packing.channelType || definition.key,
+    templateDir: packing.templateDir || definition.key,
+    artifactFileName: packing.artifactFileName || `channel-${definition.key}.json`,
+    artifactFormat: packing.artifactFormat || 'json',
+    displayLabel: packing.displayLabel || definition.displayName,
+    category: packing.category || 'communication',
+    wizardOrder: Number.isInteger(packing.wizardOrder) ? packing.wizardOrder : 100,
+    remainingManualStep: packing.remainingManualStep || '',
+    docsAnchor: packing.docsAnchor || definition.key,
+    approvalRequired: packing.approvalRequired !== false,
+    vendorAuthRequired: packing.vendorAuthRequired !== false,
+    capabilities: Array.isArray(packing.capabilities)
+      ? [...packing.capabilities]
+      : [...DEFAULT_CAPABILITIES]
+  };
+}
+
+/**
+ * @param {Object} definition
+ * @returns {Object}
+ */
+function toChannelTargetProjection(definition) {
+  const packing = packagingOf(definition);
+  const channel = definition.channel || {};
+  return {
+    key: definition.key,
+    ...packagingFields(definition, packing),
+    credentialKey: credentialKeyOf(definition, packing),
+    description: definition.description,
+    experimental: channel.experimental === true,
+    automatedProvisioning: Boolean(channel.provisioning && channel.provisioning.mode === 'automatic'),
+    provisioning: channel.provisioning || { mode: 'guided' },
+    runtimeTarget: runtimeTargetOf(definition, channel),
+    profiles: Array.isArray(channel.profiles) ? channel.profiles.map((row) => ({ ...row })) : [],
+    definitionKey: channel.definitionKey || definition.key,
+    artifacts: Array.isArray(channel.artifacts) ? [...channel.artifacts] : []
+  };
+}
+
+module.exports = {
+  packagingOf,
+  toChannelTargetProjection,
+  DEFAULT_CAPABILITIES
+};

package/lib/channels/channel-definition-registry.js

@@ -0,0 +1,154 @@
+/**
+ * Load Channel Definitions from templates/channels/<key>/channel.json.
+ *
+ * @fileoverview Canonical ES documents plus channel specialization
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const path = require('path');
+
+const TEMPLATES_ROOT = path.join(__dirname, '..', '..', 'templates', 'channels');
+const DEFAULT_RUNTIME = 'runtime-orchestration';
+
+/** @type {Map<string, Object>|null} */
+let cachedDefinitions = null;
+
+/**
+ * Disk SSOT must ignore Jest `fs` mocks (brand/ is an icon pack, not a definition).
+ * @returns {typeof import('node:fs')}
+ */
+function channelDiskFs() {
+  const jestApi = typeof globalThis.jest === 'object' ? globalThis.jest : null;
+  if (jestApi && typeof jestApi.requireActual === 'function') {
+    return jestApi.requireActual('node:fs');
+  }
+  const snap = global.__AIFABRIX_NODE_FS_UNMOCKED__;
+  if (snap && typeof snap.readdirSync === 'function' && typeof snap.readFileSync === 'function') {
+    return snap;
+  }
+  return require('node:fs');
+}
+
+/**
+ * @param {string} raw
+ * @param {string} filePath
+ * @returns {Object}
+ */
+function parseDefinition(raw, filePath) {
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== 'object' || typeof parsed.key !== 'string') {
+    throw new Error(`Invalid Channel Definition: ${filePath}`);
+  }
+  return parsed;
+}
+
+/**
+ * @param {object} disk
+ * @param {string} templatesRoot
+ * @param {string} name
+ * @param {Map<string, Object>} map
+ * @returns {void}
+ */
+function loadOneDefinition(disk, templatesRoot, name, map) {
+  if (typeof name !== 'string' || name.startsWith('.')) {
+    return;
+  }
+  const filePath = path.join(templatesRoot, name, 'channel.json');
+  let raw;
+  try {
+    raw = disk.readFileSync(filePath, 'utf8');
+  } catch (err) {
+    if (err && (err.code === 'ENOENT' || err.code === 'EISDIR' || err.code === 'ENOTDIR')) {
+      return;
+    }
+    throw err;
+  }
+  if (typeof raw !== 'string' || !raw.trim()) {
+    return;
+  }
+  const definition = parseDefinition(raw, filePath);
+  map.set(definition.key, definition);
+}
+
+/**
+ * @param {string} [templatesRoot]
+ * @returns {Map<string, Object>}
+ */
+function loadChannelDefinitions(templatesRoot = TEMPLATES_ROOT) {
+  const disk = channelDiskFs();
+  const map = new Map();
+  let names;
+  try {
+    names = disk.readdirSync(templatesRoot);
+  } catch {
+    return map;
+  }
+  if (!Array.isArray(names)) {
+    return map;
+  }
+  for (const name of names) {
+    loadOneDefinition(disk, templatesRoot, name, map);
+  }
+  return map;
+}
+
+/**
+ * @returns {Map<string, Object>}
+ */
+function getChannelDefinitionMap() {
+  if (cachedDefinitions && cachedDefinitions.size > 0) {
+    return cachedDefinitions;
+  }
+  cachedDefinitions = loadChannelDefinitions();
+  return cachedDefinitions;
+}
+
+/**
+ * Test hook — clear cached definitions.
+ * @returns {void}
+ */
+function resetChannelDefinitionCache() {
+  cachedDefinitions = null;
+}
+
+/**
+ * @param {string} key
+ * @returns {Object|null}
+ */
+function getChannelDefinition(key) {
+  return getChannelDefinitionMap().get(key) || null;
+}
+
+/**
+ * @returns {string[]}
+ */
+function listChannelDefinitionKeys() {
+  return [...getChannelDefinitionMap().keys()];
+}
+
+/**
+ * @param {Object} definition
+ * @returns {string}
+ */
+function definitionRuntimeSystemKey(definition) {
+  const fromDoc = definition && definition.channel && definition.channel.runtimeTarget;
+  if (fromDoc && typeof fromDoc.defaultSystemKey === 'string' && fromDoc.defaultSystemKey) {
+    return fromDoc.defaultSystemKey;
+  }
+  return DEFAULT_RUNTIME;
+}
+
+module.exports = {
+  TEMPLATES_ROOT,
+  DEFAULT_RUNTIME,
+  channelDiskFs,
+  loadChannelDefinitions,
+  getChannelDefinitionMap,
+  getChannelDefinition,
+  listChannelDefinitionKeys,
+  resetChannelDefinitionCache,
+  definitionRuntimeSystemKey
+};

package/lib/channels/channel-description.js

@@ -1,7 +1,7 @@
 /**
- * Slack manifest description limits (plan 152).
+ * Slack manifest description limits.
  *
- * @fileoverview Enforce Slack display_information.description max length
+ * @fileoverview Enforce Slack display_information short and long description lengths
  * @author AI Fabrix Team
  * @version 1.0.0
  */
@@ -11,6 +11,18 @@
 /** Slack manifest `display_information.description` max (api.slack.com/reference/manifests). */
 const SLACK_APP_DESCRIPTION_MAX_LENGTH = 140;
 
+/** Slack App Settings reject `long_description` shorter than this. */
+const SLACK_APP_LONG_DESCRIPTION_MIN_LENGTH = 175;
+
+/** Slack manifest `display_information.long_description` max. */
+const SLACK_APP_LONG_DESCRIPTION_MAX_LENGTH = 4000;
+
+const DEFAULT_SLACK_APP_LONG_DESCRIPTION =
+  'This Slack app connects employees to governed Role Assistants. Chat in DM, ' +
+  'follow work that needs you, and open documents waiting for review. Access is ' +
+  'limited by enterprise identity, and actions stay auditable. If a Slack ' +
+  'profile email does not match a platform user, they can still link their account.';
+
 /**
  * @param {string} description
  * @returns {string}
@@ -51,9 +63,54 @@ function resolveAppDescription(channelTarget, description) {
   return text;
 }
 
+/**
+ * @param {string} description
+ * @returns {string}
+ */
+function normalizeSlackAppLongDescription(description) {
+  const text = String(description ?? '').trim();
+  if (text.length >= SLACK_APP_LONG_DESCRIPTION_MIN_LENGTH) {
+    return text.length > SLACK_APP_LONG_DESCRIPTION_MAX_LENGTH
+      ? text.slice(0, SLACK_APP_LONG_DESCRIPTION_MAX_LENGTH)
+      : text;
+  }
+  if (!text) {
+    return DEFAULT_SLACK_APP_LONG_DESCRIPTION;
+  }
+  const combined = `${text} ${DEFAULT_SLACK_APP_LONG_DESCRIPTION}`;
+  if (combined.length > SLACK_APP_LONG_DESCRIPTION_MAX_LENGTH) {
+    return combined.slice(0, SLACK_APP_LONG_DESCRIPTION_MAX_LENGTH);
+  }
+  return combined;
+}
+
+/**
+ * @param {string} channelTarget
+ * @param {Object} runtimeValues
+ * @returns {Object}
+ */
+function fillSlackManifestDescriptions(channelTarget, runtimeValues) {
+  if (channelTarget !== 'slack' || !runtimeValues || typeof runtimeValues !== 'object') {
+    return runtimeValues;
+  }
+  const appLongDescription = normalizeSlackAppLongDescription(
+    runtimeValues.appLongDescription || runtimeValues.appDescription
+  );
+  return {
+    ...runtimeValues,
+    appLongDescription,
+    appLongDescriptionJson: JSON.stringify(appLongDescription)
+  };
+}
+
 module.exports = {
   SLACK_APP_DESCRIPTION_MAX_LENGTH,
+  SLACK_APP_LONG_DESCRIPTION_MIN_LENGTH,
+  SLACK_APP_LONG_DESCRIPTION_MAX_LENGTH,
+  DEFAULT_SLACK_APP_LONG_DESCRIPTION,
   normalizeSlackAppDescription,
+  normalizeSlackAppLongDescription,
+  fillSlackManifestDescriptions,
   assertSlackAppDescription,
   resolveAppDescription
 };

package/lib/channels/channel-discovery.js

@@ -75,6 +75,18 @@ function extractGovernedToolNames(discovery) {
   return tools.map((tool) => (tool && tool.name ? String(tool.name) : '')).filter(Boolean);
 }
 
+/**
+ * Live discovery uses `publication.remoteMcpReady`. Older fixtures used `mcpReady`.
+ * @param {Object|null|undefined} publication
+ * @returns {boolean}
+ */
+function isPublicationRemoteMcpReady(publication) {
+  if (!publication || typeof publication !== 'object') {
+    return false;
+  }
+  return publication.remoteMcpReady === true || publication.mcpReady === true;
+}
+
 /**
  * @param {Object} discovery
  * @param {Object|null} adapter
@@ -93,7 +105,7 @@ function resolveMcpConnection(discovery, adapter, dataplaneBaseUrl) {
       'Gateway tools catalog must not be used as MCP server URL for channel packages'
     );
   }
-  const mcpReady = discovery?.publication?.mcpReady === true;
+  const mcpReady = isPublicationRemoteMcpReady(discovery && discovery.publication);
   const connectable = adapter ? adapter.connectable === true : mcpReady;
   const remoteAvailable = discovery?.transport?.remoteMcp?.status === 'available';
   const installReady = Boolean(mcpReady && connectable && remoteAvailable && mcpServerUrl);
@@ -213,7 +225,8 @@ function mapDiscoveryToPackageContext(params) {
     authentication: mapAdapterAuthentication(adapter?.authentication || null),
     authenticationCapabilities: authCaps,
     publication: {
-      mcpReady: discovery.publication?.mcpReady === true,
+      mcpReady: isPublicationRemoteMcpReady(discovery.publication),
+      remoteMcpReady: isPublicationRemoteMcpReady(discovery.publication),
       environment: discovery.publication?.environment || null
     },
     brandingApplied: isBrandingApplied(branding)
@@ -321,6 +334,7 @@ async function loadChannelPackageContext(params) {
 module.exports = {
   GATEWAY_TOOLS_CATALOG_MARKER,
   isGatewayToolsCatalogUrl,
+  isPublicationRemoteMcpReady,
   resolveDiscoveryUrl,
   mapDiscoveryToPackageContext,
   fetchExternalAiDiscovery,