@aifabrix/builder 2.53.1 → 2.55.0

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-definition-status.js

@@ -0,0 +1,115 @@
+/**
+ * Channel Definition catalog/install status (visible | hide | coming-soon).
+ *
+ * @fileoverview Omit or visible: listed and installable. hide: omitted and refused. coming-soon: listed read-only.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const registry = require('./channel-definition-registry');
+
+const CHANNEL_STATUSES = ['visible', 'hide', 'coming-soon'];
+const COMING_SOON_REASON = 'This channel is coming soon.';
+const HIDE_REASON = 'This channel is not available.';
+
+/**
+ * @param {Object|null} definition
+ * @returns {'visible'|'hide'|'coming-soon'}
+ */
+function normalizeChannelStatus(definition) {
+  const raw = definition && definition.channel && definition.channel.status;
+  if (raw === 'hide' || raw === 'coming-soon') {
+    return raw;
+  }
+  return 'visible';
+}
+
+/**
+ * Live status from the Channel Definition registry (spy-friendly).
+ * @param {string} key
+ * @returns {'visible'|'hide'|'coming-soon'}
+ */
+function channelStatusOf(key) {
+  return normalizeChannelStatus(registry.getChannelDefinition(key));
+}
+
+/**
+ * @param {string} status
+ * @returns {boolean}
+ */
+function isCatalogHiddenStatus(status) {
+  return status === 'hide';
+}
+
+/**
+ * @param {string} status
+ * @returns {boolean}
+ */
+function isInstallableStatus(status) {
+  return status === 'visible';
+}
+
+/**
+ * @param {string} key
+ * @param {string} status
+ * @returns {Error}
+ */
+function statusUnavailableError(key, status) {
+  const message =
+    status === 'coming-soon'
+      ? `Channel target "${key}" is coming soon.`
+      : `Channel target "${key}" is not available.`;
+  const err = new Error(message);
+  err.statusCode = 403;
+  return err;
+}
+
+/**
+ * Refuse new install for hide and coming-soon. Continue of an existing session skips.
+ * --force / allowExperimental do not override.
+ * @param {string} key
+ * @param {{ continueInstall?: boolean }} [options]
+ * @returns {void}
+ */
+function assertChannelStatusInstallable(key, options = {}) {
+  if (options.continueInstall === true) {
+    return;
+  }
+  const status = channelStatusOf(key);
+  if (isInstallableStatus(status)) {
+    return;
+  }
+  throw statusUnavailableError(key, status);
+}
+
+/**
+ * Overlay coming-soon onto a catalog/detail projection (canInstall false).
+ * @param {string} status
+ * @param {Object} [projection]
+ * @returns {Object}
+ */
+function applyChannelStatusProjection(status, projection = {}) {
+  if (status !== 'coming-soon') {
+    return { ...projection, status };
+  }
+  return {
+    ...projection,
+    status,
+    canInstall: false,
+    blockedReason: COMING_SOON_REASON
+  };
+}
+
+module.exports = {
+  CHANNEL_STATUSES,
+  COMING_SOON_REASON,
+  HIDE_REASON,
+  normalizeChannelStatus,
+  channelStatusOf,
+  isCatalogHiddenStatus,
+  isInstallableStatus,
+  assertChannelStatusInstallable,
+  applyChannelStatusProjection
+};