@aifabrix/builder 2.53.1 → 2.55.0

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,55 @@ 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),
+    enableMcpServer: runtimeValues.enableMcpServer === true
+  };
+}
+
 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,

package/lib/channels/channel-external-system.js

@@ -8,13 +8,39 @@
 
 'use strict';
 
-const { getExternalSystem, updateExternalSystem } = require('../api/external-systems.api');
+const {
+  getExternalSystem,
+  getExternalSystemConfig,
+  updateExternalSystem
+} = require('../api/external-systems.api');
 const { unwrapApiData } = require('../utils/external-system-readiness-core');
 
 /**
  * @param {Object|null} system
  * @returns {Object|null}
  */
+/**
+ * Connected System key for fetch/patch (instance, not definition).
+ * @param {Object} ctx
+ * @returns {string}
+ */
+function communicationSystemKey(ctx) {
+  const instanceKey = ctx && typeof ctx.instanceSystemKey === 'string'
+    ? ctx.instanceSystemKey.trim()
+    : '';
+  if (!instanceKey) {
+    throw new Error(
+      'Connected System instance key is required. Derive it from the display name; it cannot equal the catalog key.'
+    );
+  }
+  if (ctx.channelTarget && instanceKey === ctx.channelTarget) {
+    throw new Error(
+      `Connected System key cannot equal the catalog key. Use ${ctx.channelTarget}-<name-slug>.`
+    );
+  }
+  return instanceKey;
+}
+
 function getExistingChannelExtension(system) {
   if (!system || typeof system !== 'object') return null;
   const channel = system.config?.extensions?.channel;
@@ -32,7 +58,7 @@ function getExistingChannelExtension(system) {
  * @returns {Object}
  */
 function buildChannelExtensionBlock(params, target) {
-  return {
+  const block = {
     type: target.channelType,
     name: params.name,
     baseName: params.baseName,
@@ -40,8 +66,20 @@ function buildChannelExtensionBlock(params, target) {
     capabilities: [...target.capabilities],
     status: params.status,
     artifactHash: params.artifactHash,
-    credentialKey: target.credentialKey
+    credentialKey: target.credentialKey,
+    definitionKey: target.definitionKey || target.key
   };
+  const prefix =
+    typeof params.commandPrefix === 'string' ? params.commandPrefix.trim().toLowerCase() : '';
+  if (prefix) {
+    block.commandPrefix = prefix;
+  }
+  const packageVersion =
+    typeof params.packageVersion === 'string' ? params.packageVersion.trim() : '';
+  if (packageVersion) {
+    block.packageVersion = packageVersion;
+  }
+  return block;
 }
 
 /**
@@ -55,7 +93,13 @@ function mergeChannelIntoSystem(system, channelBlock) {
     config.extensions && typeof config.extensions === 'object' ? { ...config.extensions } : {};
   extensions.channel = channelBlock;
   config.extensions = extensions;
-  return { ...system, config, displayName: channelBlock.name };
+  const definitionKey =
+    channelBlock.definitionKey || (system.channel && system.channel.definitionKey);
+  const channel = {
+    ...(system.channel && typeof system.channel === 'object' ? system.channel : {}),
+    definitionKey
+  };
+  return { ...system, config, displayName: channelBlock.name, channel };
 }
 
 /**
@@ -67,11 +111,14 @@ function mergeChannelIntoSystem(system, channelBlock) {
  * @returns {Promise<Object>}
  */
 async function fetchCommunicationSystem(ctx) {
-  const res = await getExternalSystem(ctx.dataplaneUrl, ctx.channelTarget, ctx.authConfig);
+  const res = await getExternalSystem(ctx.dataplaneUrl, communicationSystemKey(ctx), ctx.authConfig);
   const system = unwrapApiData(res);
   if (!system || typeof system !== 'object') {
+    if (ctx.allowMissing === true) {
+      return null;
+    }
     throw new Error(
-      `Communication external system "${ctx.channelTarget}" was not found. ` +
+      `Communication external system "${communicationSystemKey(ctx)}" was not found. ` +
         `Run: aifabrix channel add ${ctx.channelTarget} --name "…" --force`
     );
   }
@@ -84,6 +131,29 @@ async function fetchCommunicationSystem(ctx) {
   return system;
 }
 
+/**
+ * GET /systems/{key} serializes a slim ExternalSystemConfig and drops
+ * authentications[]. Use the running manifest so inbound HMAC survives PUT.
+ *
+ * @param {Object} ctx
+ * @param {Object} system
+ * @returns {Promise<Object>}
+ */
+async function loadSystemConfigForChannelPatch(ctx, system) {
+  const getConfig = ctx.getExternalSystemConfig || getExternalSystemConfig;
+  try {
+    const res = await getConfig(ctx.dataplaneUrl, communicationSystemKey(ctx), ctx.authConfig);
+    const body = unwrapApiData(res) || res;
+    const application = body && body.application;
+    if (application && typeof application === 'object') {
+      return application;
+    }
+  } catch {
+    /* keep GET-by-id config */
+  }
+  return system.config && typeof system.config === 'object' ? system.config : {};
+}
+
 /**
  * @async
  * @param {Object} ctx
@@ -92,8 +162,14 @@ async function fetchCommunicationSystem(ctx) {
  */
 async function patchChannelExtension(ctx, channelBlock) {
   const system = await fetchCommunicationSystem(ctx);
-  const merged = mergeChannelIntoSystem(system, channelBlock);
-  const res = await updateExternalSystem(ctx.dataplaneUrl, ctx.channelTarget, ctx.authConfig, merged);
+  const config = await loadSystemConfigForChannelPatch(ctx, system);
+  const merged = mergeChannelIntoSystem({ ...system, config }, channelBlock);
+  const res = await updateExternalSystem(
+    ctx.dataplaneUrl,
+    communicationSystemKey(ctx),
+    ctx.authConfig,
+    { displayName: merged.displayName, config: merged.config, channel: merged.channel }
+  );
   return unwrapApiData(res) || merged;
 }
 
@@ -102,5 +178,6 @@ module.exports = {
   buildChannelExtensionBlock,
   mergeChannelIntoSystem,
   fetchCommunicationSystem,
-  patchChannelExtension
+  patchChannelExtension,
+  communicationSystemKey
 };

package/lib/channels/channel-install-envelope-actions.js

@@ -0,0 +1,88 @@
+/**
+ * Shared ChannelInstallEnvelope user-action builders.
+ *
+ * @fileoverview Keep envelope.js under the file-size limit
+ */
+
+'use strict';
+
+/**
+ * @param {Object} params
+ * @param {string} params.id
+ * @param {string} params.kind
+ * @param {string} params.label
+ * @param {boolean} [params.required]
+ * @param {string} [params.resume]
+ * @param {Object} [params.extra]
+ * @returns {Object}
+ */
+function userAction(params) {
+  return {
+    id: params.id,
+    kind: params.kind,
+    label: params.label,
+    required: params.required !== false,
+    resume: params.resume || 'poll',
+    ...(params.extra || {})
+  };
+}
+
+/**
+ * @param {string} href
+ * @param {string} label
+ * @param {string} id
+ * @param {boolean} [required]
+ * @returns {Object|null}
+ */
+function openUrlAction(href, label, id, required) {
+  if (typeof href !== 'string' || !href.trim()) {
+    return null;
+  }
+  return userAction({
+    id,
+    kind: 'openUrl',
+    label,
+    required,
+    extra: { href: href.trim() }
+  });
+}
+
+/**
+ * @param {string} label
+ * @param {string} value
+ * @param {string} id
+ * @returns {Object|null}
+ */
+function copyValueAction(label, value, id) {
+  if (typeof value !== 'string' || !value.trim()) {
+    return null;
+  }
+  return userAction({
+    id,
+    kind: 'copyValue',
+    label,
+    extra: { value: value.trim() }
+  });
+}
+
+/**
+ * @param {string} text
+ * @param {string} id
+ * @returns {Object}
+ */
+function remainingStepAction(text, id) {
+  return userAction({
+    id,
+    kind: 'remainingVendorStep',
+    label: text,
+    required: false,
+    extra: { text }
+  });
+}
+
+module.exports = {
+  userAction,
+  openUrlAction,
+  copyValueAction,
+  remainingStepAction
+};

package/lib/channels/channel-install-envelope-microsoft.js

@@ -0,0 +1,155 @@
+/**
+ * Microsoft Copilot and Teams Bot envelope actions.
+ *
+ * @fileoverview Sign-in / continue handoff for portal install
+ */
+
+'use strict';
+
+const { userAction, copyValueAction } = require('./channel-install-envelope-actions');
+
+/**
+ * @param {Object|null} runtimeValues
+ * @returns {boolean}
+ */
+function copilotVaultMissing(runtimeValues) {
+  return !(
+    runtimeValues &&
+    typeof runtimeValues.oauthPluginVaultReferenceId === 'string' &&
+    runtimeValues.oauthPluginVaultReferenceId.trim()
+  );
+}
+
+/**
+ * @param {Object} params
+ * @returns {boolean}
+ */
+function copilotWaitingNoLoginUrl(params) {
+  const values = params.runtimeValues || {};
+  return (
+    params.channelTarget === 'microsoft-copilot' &&
+    copilotVaultMissing(values) &&
+    values.microsoftAuthConfigFallback !== true &&
+    !(typeof values.microsoftLoginUrl === 'string' && values.microsoftLoginUrl.trim())
+  );
+}
+
+/**
+ * @param {Object} params
+ * @returns {boolean}
+ */
+function teamsBotWaiting(params) {
+  return params.channelTarget === 'teams-bot' && Boolean(params.ctx && params.ctx.teamsBotSkipped);
+}
+
+/**
+ * @param {Object} params
+ * @returns {boolean}
+ */
+function microsoftLoginWaiting(params) {
+  if (teamsBotWaiting(params)) {
+    return true;
+  }
+  const waitingNoUrl = copilotWaitingNoLoginUrl(params);
+  return (
+    params.channelTarget === 'microsoft-copilot' &&
+    copilotVaultMissing(params.runtimeValues) &&
+    (params.runtimeValues || {}).microsoftAuthConfigFallback !== true &&
+    waitingNoUrl !== true
+  ) || waitingNoUrl;
+}
+
+/**
+ * @param {Object} params
+ * @returns {Object|null}
+ */
+function continueAfterMicrosoftLoginAction(params) {
+  const values = params.runtimeValues || {};
+  const teams = teamsBotWaiting(params);
+  if (params.channelTarget === 'microsoft-copilot') {
+    if (!copilotVaultMissing(values) || values.microsoftAuthConfigFallback === true) {
+      return null;
+    }
+  } else if (!teams) {
+    return null;
+  }
+  const loginUrl =
+    typeof values.microsoftLoginUrl === 'string' ? values.microsoftLoginUrl.trim() : '';
+  return userAction({
+    id: 'continue-after-microsoft-login',
+    kind: 'submitInput',
+    label: loginUrl ? 'Continue after sign-in' : 'Continue'
+  });
+}
+
+/**
+ * @param {Object} params
+ * @returns {Object[]}
+ */
+function microsoftLoginCodeActions(params) {
+  const actions = [];
+  const code =
+    params.runtimeValues && typeof params.runtimeValues.microsoftLoginUserCode === 'string'
+      ? params.runtimeValues.microsoftLoginUserCode.trim()
+      : '';
+  const copy = copyValueAction('Enter this code', code, 'copy-microsoft-login-code');
+  if (copy) {
+    actions.push(copy);
+  }
+  const resume = continueAfterMicrosoftLoginAction(params);
+  if (resume) {
+    actions.push(resume);
+  }
+  return actions;
+}
+
+/**
+ * @param {Object} params
+ * @returns {Object[]}
+ */
+function copilotExtraActions(params) {
+  if (params.channelTarget !== 'microsoft-copilot') {
+    return [];
+  }
+  if (!copilotVaultMissing(params.runtimeValues)) {
+    return [];
+  }
+  if (params.runtimeValues && params.runtimeValues.microsoftAuthConfigFallback === true) {
+    return [
+      userAction({
+        id: 'submit-entra-sso-registration',
+        kind: 'submitInput',
+        label: 'Paste the Microsoft auth-config ID (fallback)',
+        extra: { field: 'oauthPluginVaultReferenceId' }
+      })
+    ];
+  }
+  return microsoftLoginCodeActions(params);
+}
+
+/**
+ * @param {Object} params
+ * @returns {Object[]}
+ */
+function teamsBotExtraActions(params) {
+  if (!teamsBotWaiting(params)) {
+    return [];
+  }
+  return microsoftLoginCodeActions(params);
+}
+
+/**
+ * @param {Object} params
+ * @returns {Object[]}
+ */
+function microsoftExtraActions(params) {
+  return [...copilotExtraActions(params), ...teamsBotExtraActions(params)];
+}
+
+module.exports = {
+  copilotVaultMissing,
+  copilotWaitingNoLoginUrl,
+  teamsBotWaiting,
+  microsoftLoginWaiting,
+  microsoftExtraActions
+};