@aifabrix/builder 2.54.1 → 2.55.2

package/lib/app/show.js

@@ -33,6 +33,8 @@ const {
   attachCertificationVerifyFromDataplane,
   sanitizeCertificationForJson
 } = require('./certification-show-enrich');
+const { resolveManifestAuthMethod } = require('../utils/external-system-readiness-compact-display');
+const { resolveAuthenticationSlots } = require('../utils/authentication-slot-show');
 
 /**
  * Attach `runReloadDefault` / `runProxyDefault` from ~/.aifabrix `applications.<appKey>`.
@@ -466,6 +468,13 @@ function pickExternalVersion(res, config, system) {
   return (res && res.version) ?? config.version ?? system.version ?? '—';
 }
 
+function pickCredentialMethod(config, system) {
+  const source = config && (config.authentication || config.authentications) ? config : system;
+  const method = resolveManifestAuthMethod(source);
+  if (!method || method === 'unknown') return undefined;
+  return method;
+}
+
 function resolveExternalSystemMeta(res, config, system, application, appKey) {
   return {
     displayName: pickExternalDisplayName(res, system, application, appKey),
@@ -501,13 +510,27 @@ function buildBaseExternalResult(configData, appKey, openapiFiles, openapiEndpoi
       permissions: application.permissions
     },
     openapiFiles,
-    openapiEndpoints
+    openapiEndpoints,
+    credentialMethod: pickCredentialMethod(config, system),
+    authenticationSlots: resolveAuthenticationSlots(config, system)
   };
 }
 
+function applyCredentialFieldsToResult(result, res) {
+  if (res.credentialId !== undefined && res.credentialId !== null) result.credentialId = res.credentialId;
+  if (res.authenticationStatus !== undefined && res.authenticationStatus !== null) {
+    result.authenticationStatus = res.authenticationStatus;
+  }
+  const resConfig = res.config && typeof res.config === 'object' ? res.config : {};
+  const fromConfig = pickCredentialMethod(resConfig, {});
+  if (fromConfig) result.credentialMethod = fromConfig;
+  const fromSlots = resolveAuthenticationSlots(resConfig, {});
+  if (fromSlots.length > 0) result.authenticationSlots = fromSlots;
+}
+
 function applySystemResponseToResult(result, res) {
   result.dataplaneStatus = res.status;
-  if (res.credentialId !== undefined && res.credentialId !== null) result.credentialId = res.credentialId;
+  applyCredentialFieldsToResult(result, res);
   if (res.showOpenApiDocs !== undefined) result.showOpenApiDocs = res.showOpenApiDocs;
   if (res.mcpServerUrl !== undefined && res.mcpServerUrl !== null) result.mcpServerUrl = res.mcpServerUrl;
   if (res.apiDocumentUrl !== undefined && res.apiDocumentUrl !== null) result.apiDocumentUrl = res.apiDocumentUrl;

package/lib/channels/add-channel.js

@@ -350,6 +350,7 @@ async function resolveInstallRuntimeValues(params, packageContext, runtimeToolNa
     appDescription: description,
     icon: options.icon,
     commandPrefix: options.commandPrefix,
+    enableMcpServer: options.enableMcpServer,
     layerBToolNames: runtimeToolNames,
     packageContext,
     entraProvider,

package/lib/channels/approval-guides/claude.js

@@ -1,7 +1,7 @@
 /**
  * Claude remaining workspace steps (customer-facing).
  *
- * @fileoverview Short Claude connector Name and Server URL steps — no protocol dump
+ * @fileoverview Short Claude connector Name, Server URL, and OAuth steps — no protocol dump
  */
 
 'use strict';
@@ -21,7 +21,7 @@ function buildClaudeApprovalGuide(ctx) {
     credentialPortalUrl: null,
     steps: [
       `Open ${CLAUDE_CONNECTORS_URL}`,
-      `Add a custom connector with Name: ${name}; Server URL: ${serverUrl}.`
+      `Add a custom connector with Name: ${name}; Server URL: ${serverUrl}; Authentication: OAuth.`
     ]
   };
 }

package/lib/channels/channel-add-failure.js

@@ -16,6 +16,7 @@ const BOUNDARY_MATCHERS = [
     tests: [/unknown channel/i, /already configured/i, /needs a terminal/i, /--name is required/i, /needs --target/i, /unknown mcp client profile/i]
   },
   { boundary: 'experimental', tests: [/is experimental/i] },
+  { boundary: 'unavailable', tests: [/is coming soon/i, /is not available/i] },
   { boundary: 'preflight', tests: [/chatgpt preflight/i, /claude preflight/i, /mcp client preflight/i, /authentication required/i, /dataplanebaseurl is required/i] },
   { boundary: 'callback', tests: [/chatgpt callback/i, /claude callback/i, /mcp client callback/i] },
   { boundary: 'oauth', tests: [/oauth/i, /trustedissuer/i, /vault-reference/i] },

package/lib/channels/channel-add-remaining.js

@@ -30,6 +30,7 @@ const { printMcpClientDryRunTty } = require('./mcp-client-channel-add');
 const { printClaudeDryRunTty } = require('./claude-channel-add');
 const { CLAUDE_REMAINING_STEPS } = require('./claude-runtime-contract');
 const { vendorFacingUrlsFromCtx } = require('./vendor-dataplane-url');
+const { slackMcpRemainingSteps } = require('./slack-mcp-runtime');
 const {
   channelDisplayLabel,
   printValidating,
@@ -280,18 +281,23 @@ function slackRecoveryOrHandshake(ctx, custom) {
  * @param {Object|null} ctx
  * @returns {Object}
  */
-function slackRemainingSpec(ctx) {
+function slackRemainingSpec(ctx, runtimeValues) {
   const custom = slackCustomSteps(ctx);
+  const mcpSteps = slackMcpRemainingSteps(runtimeValues);
+  let spec;
   if (ctx && ctx.slackConnected === true) {
-    return slackConnectedRemaining(ctx, custom);
+    spec = slackConnectedRemaining(ctx, custom);
+  } else if (ctx && ctx.slackSlashCommand) {
+    spec = slackSlashRemaining(ctx, custom);
+  } else if (ctx && ctx.slackHandshakeFailed === true) {
+    spec = slackFailedRemaining(custom);
+  } else {
+    spec = slackRecoveryOrHandshake(ctx, custom);
   }
-  if (ctx && ctx.slackSlashCommand) {
-    return slackSlashRemaining(ctx, custom);
+  if (mcpSteps.length === 0) {
+    return spec;
   }
-  if (ctx && ctx.slackHandshakeFailed === true) {
-    return slackFailedRemaining(custom);
-  }
-  return slackRecoveryOrHandshake(ctx, custom);
+  return { ...spec, steps: [...(spec.steps || []), ...mcpSteps] };
 }
 
 /**
@@ -350,7 +356,7 @@ function teamsBotRemainingSpec(ctx, runtimeValues) {
  */
 function remainingSpec(channelTarget, ctx, runtimeValues) {
   if (channelTarget === 'slack') {
-    return slackRemainingSpec(ctx);
+    return slackRemainingSpec(ctx, runtimeValues);
   }
   if (channelTarget === 'microsoft-copilot') {
     return copilotRemainingSpec(ctx, runtimeValues);

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
+};

package/lib/channels/channel-description.js

@@ -99,7 +99,8 @@ function fillSlackManifestDescriptions(channelTarget, runtimeValues) {
   return {
     ...runtimeValues,
     appLongDescription,
-    appLongDescriptionJson: JSON.stringify(appLongDescription)
+    appLongDescriptionJson: JSON.stringify(appLongDescription),
+    enableMcpServer: runtimeValues.enableMcpServer === true
   };
 }
 

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

@@ -135,7 +135,8 @@ function claudeCopyActions(runtimeValues) {
   const values = buildClaudeFormValues({ runtimeValues: runtimeValues || {} });
   return [
     copyValueAction('Name', values.name, 'copy-name'),
-    copyValueAction('Server URL', values.serverUrl, 'copy-server-url')
+    copyValueAction('Server URL', values.serverUrl, 'copy-server-url'),
+    copyValueAction('Authentication', values.authentication, 'copy-authentication')
   ].filter(Boolean);
 }
 
@@ -195,7 +196,8 @@ function claudeEnvelopeParts(params) {
     useValues: runtimeOk
       ? {
         Name: values.name,
-        'Server URL': values.serverUrl
+        'Server URL': values.serverUrl,
+        Authentication: values.authentication
       }
       : {}
   };

package/lib/channels/channel-integration-generator.js

@@ -12,6 +12,7 @@
 
 const path = require('path');
 const { getChannelTarget } = require('./channel-targets');
+const { assertChannelStatusInstallable } = require('./channel-definition-status');
 const { getIntegrationPath } = require('../utils/paths');
 const {
   copyChannelIntegrationTemplate,
@@ -29,6 +30,7 @@ const { generateDeployJson } = require('../generator/index');
  */
 async function scaffoldChannelIntegration(channelTarget, options = {}) {
   const target = getChannelTarget(channelTarget);
+  assertChannelStatusInstallable(channelTarget, options);
   if (target.experimental && !options.allowExperimental) {
     throw new Error(
       `Channel target "${channelTarget}" is experimental. Pass --allow-experimental to scaffold.`

package/lib/channels/channel-runtime-resolver.js

@@ -36,6 +36,7 @@ const { applyCopilotOauthProfile, applyCopilotRuntimeDomain } = require('./chann
 const { chatgptDiscoveryBlockerLabel } = require('./chatgpt-setup-values');
 const { applyMcpClientRuntimeValues } = require('./mcp-client/runtime');
 const { applyClaudeRuntimeValues } = require('./claude-runtime');
+const { applySlackMcpRuntimeValues } = require('./slack-mcp-runtime');
 
 const DEFAULT_SLACK_COMMAND_PREFIX = 'af';
 
@@ -347,6 +348,7 @@ function applySlackRuntimeValues(resolved, params) {
   Object.assign(resolved, resolveSlackOAuthManifestFields());
   delete resolved.oauthCallbackUrl;
   resolved.commandPrefix = normalizeSlackCommandPrefix(params.commandPrefix);
+  resolved.enableMcpServer = isTrueLike(params.enableMcpServer);
   resolved.packageVersion =
     typeof params.packageVersion === 'string' && params.packageVersion.trim()
       ? params.packageVersion.trim()
@@ -356,6 +358,17 @@ function applySlackRuntimeValues(resolved, params) {
   resolved.appLongDescriptionJson = JSON.stringify(appLongDescription);
 }
 
+/**
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+function isTrueLike(value) {
+  if (value === true) {
+    return true;
+  }
+  return typeof value === 'string' && /^(true|1|yes|on)$/i.test(value.trim());
+}
+
 /**
  * Slack slash alias prefix: letters then letters/digits, 1–16 chars.
  * @param {unknown} raw
@@ -438,6 +451,7 @@ function applyChannelSpecificRuntime(resolved, params) {
   if (params.channelTarget === 'slack') {
     applySlackRuntimeValues(resolved, params);
     applyDiscoveryPackageContext(resolved, params.packageContext);
+    applySlackMcpRuntimeValues(resolved, params);
   }
   if (params.channelTarget === 'microsoft-copilot') {
     applyMicrosoftCopilotRuntimeValues(resolved, params);

package/lib/channels/channel-targets.js

@@ -14,6 +14,12 @@ const {
   listChannelDefinitionKeys
 } = require('./channel-definition-registry');
 const { toChannelTargetProjection } = require('./channel-definition-project');
+const {
+  assertChannelStatusInstallable,
+  channelStatusOf,
+  isCatalogHiddenStatus,
+  isInstallableStatus
+} = require('./channel-definition-status');
 
 function buildChannelTargets() {
   const targets = {};
@@ -48,15 +54,21 @@ function isChannelTargetKey(channelTarget) {
  */
 function formatSupportedChannelTargetsHelp() {
   const targets = resolveChannelTargets();
-  const keys = Object.keys(targets);
-  const stable = keys.filter((key) => !targets[key].experimental);
-  const experimental = keys.filter((key) => targets[key].experimental);
+  const installable = listInstallableChannelTargetKeys({ allowExperimental: true });
+  const stable = installable.filter((key) => !targets[key].experimental);
+  const experimental = installable.filter((key) => targets[key].experimental);
+  const comingSoon = listLiveChannelTargetKeys({ allowExperimental: true }).filter(
+    (key) => channelStatusOf(key) === 'coming-soon'
+  );
   const lines = ['Supported channels:', `  ${stable.join(', ')}`];
   if (experimental.length > 0) {
     lines.push(
       `  ${experimental.join(', ')} (experimental — scaffold with --allow-experimental)`
     );
   }
+  if (comingSoon.length > 0) {
+    lines.push(`  ${comingSoon.join(', ')} (coming soon — not installable)`);
+  }
   return lines.join('\n');
 }
 
@@ -81,18 +93,30 @@ function getChannelTarget(channelTarget) {
 }
 
 /**
- * Live keys, plus experimental when `--allow-experimental` is set.
+ * Live keys (not hide), plus experimental when `--allow-experimental` is set.
  * @param {{ allowExperimental?: boolean }} [options]
  * @returns {string[]}
  */
 function listLiveChannelTargetKeys(options = {}) {
   const targets = resolveChannelTargets();
   return Object.keys(targets).filter((key) => {
+    if (isCatalogHiddenStatus(channelStatusOf(key))) {
+      return false;
+    }
     const target = targets[key];
     return !target.experimental || options.allowExperimental === true;
   });
 }
 
+/**
+ * Keys that may start a new install (visible). Coming-soon is catalog-only.
+ * @param {{ allowExperimental?: boolean }} [options]
+ * @returns {string[]}
+ */
+function listInstallableChannelTargetKeys(options = {}) {
+  return listLiveChannelTargetKeys(options).filter((key) => isInstallableStatus(channelStatusOf(key)));
+}
+
 /**
  * Inquirer list choices for `aifabrix channel add` (labels from the registry).
  * @param {{ allowExperimental?: boolean }} [options]
@@ -100,7 +124,7 @@ function listLiveChannelTargetKeys(options = {}) {
  */
 function listWizardChannelChoices(options = {}) {
   const targets = resolveChannelTargets();
-  return listLiveChannelTargetKeys(options)
+  return listInstallableChannelTargetKeys(options)
     .map((key) => targets[key])
     .sort((a, b) => (a.wizardOrder || 100) - (b.wizardOrder || 100))
     .map((target) => ({ name: target.displayLabel, value: target.key }));
@@ -114,6 +138,7 @@ function listWizardChannelChoices(options = {}) {
  */
 function assertChannelTargetInstallable(channelTarget, options = {}) {
   const target = getChannelTarget(channelTarget);
+  assertChannelStatusInstallable(channelTarget, options);
   if (target.experimental && options.allowExperimental !== true) {
     throw new Error(
       `Channel target "${channelTarget}" is experimental. Pass --allow-experimental to install.`
@@ -146,6 +171,7 @@ module.exports = {
   formatSupportedChannelTargetsHelp,
   formatUnknownChannelTargetError,
   listLiveChannelTargetKeys,
+  listInstallableChannelTargetKeys,
   listWizardChannelChoices,
   assertChannelTargetInstallable,
   getChannelDefinition,

package/lib/channels/claude-setup-values.js

@@ -1,5 +1,5 @@
 /**
- * Customer-facing Claude connector form values: Name and Server URL.
+ * Customer-facing Claude connector form values: Name, Server URL, OAuth.
  *
  * @fileoverview Claude channel form values — describe, don't configure
  */
@@ -78,6 +78,9 @@ function formatClaudeFormValueLines(values) {
   if (values.serverUrl) {
     lines.push(`Server URL: ${values.serverUrl}`);
   }
+  if (values.authentication) {
+    lines.push(`Authentication: ${values.authentication}`);
+  }
   return lines;
 }
 

package/lib/channels/slack-channel-add.js

@@ -21,6 +21,7 @@ const {
   maybeOnboardSlackUsers,
   unmatchedRemainingStep
 } = require('./slack-provisioning/onboard');
+const { registerSlackMcpCallback, slackMcpProfileUrl } = require('./slack-mcp-callback');
 
 /**
  * @param {Error} error
@@ -223,36 +224,88 @@ async function recoverOrRefreshAuth(error, params, options, deps, ctx, projectRo
  * @param {Object} params
  * @returns {Promise<Object|null>}
  */
-async function maybeProvisionSlackChannel(params) {
-  if (!params || params.channelTarget !== 'slack') {
+async function maybeRegisterSlackMcpCallback(params) {
+  const runtime = params && params.runtimeValues;
+  const ctx = params && params.ctx;
+  if (!runtime || !runtime.enableMcpServer) {
     return null;
   }
-  if (params.options && params.options.dryRun === true) {
+  if (!ctx || !ctx.controllerUrl || !ctx.authConfig) {
+    return {
+      ok: false,
+      fallback: true,
+      remaining: ['Open the OAuth2 profile and add the Slack MCP callback URL']
+    };
+  }
+  try {
+    const result = await registerSlackMcpCallback({ ctx, ...(params.slackMcpCallbackDeps || {}) });
+    if (result && result.fallback) {
+      const profileUrl = result.profileUrl || slackMcpProfileUrl(ctx);
+      return {
+        ok: false,
+        fallback: true,
+        remaining: [`Open ${profileUrl} and add the Slack MCP callback URL`]
+      };
+    }
+    return result;
+  } catch (error) {
+    return {
+      ok: false,
+      fallback: true,
+      remaining: [error && error.message ? error.message : 'Slack MCP callback could not be registered']
+    };
+  }
+}
+
+/**
+ * @param {Object} params
+ * @returns {Promise<Object|null>}
+ */
+async function maybeProvisionSlackChannel(params) {
+  if (!params || params.channelTarget !== 'slack' || (params.options && params.options.dryRun === true)) {
     return null;
   }
   const ctx = params.ctx || {};
   const options = params.options || {};
   const deps = slackDepsFromOptions(options);
   const projectRoot = options.projectRoot || process.cwd();
+  const mcpCallback = await maybeRegisterSlackMcpCallback(params);
   if (options.quiet === true) {
     const portal = await preparePortalSlackAuth(options, deps);
     if (portal.waiting) {
       await publishSlackAfterSecrets({ connected: false }, options, deps);
-      return portal.result;
+      return attachSlackMcpRemaining(portal.result, mcpCallback);
     }
   }
   try {
     if (options.quiet !== true) {
       await ensureSlackCliReady(options, deps);
     }
-    return await provisionAndPublish(params, options, deps, ctx, projectRoot);
+    const result = await provisionAndPublish(params, options, deps, ctx, projectRoot);
+    return attachSlackMcpRemaining(result, mcpCallback);
   } catch (error) {
-    return recoverOrRefreshAuth(error, params, options, deps, ctx, projectRoot);
+    const recovered = await recoverOrRefreshAuth(error, params, options, deps, ctx, projectRoot);
+    return attachSlackMcpRemaining(recovered, mcpCallback);
+  }
+}
+
+/**
+ * @param {Object|null} result
+ * @param {Object|null} mcpCallback
+ * @returns {Object|null}
+ */
+function attachSlackMcpRemaining(result, mcpCallback) {
+  const extra = mcpCallback && Array.isArray(mcpCallback.remaining) ? mcpCallback.remaining : [];
+  if (extra.length === 0) {
+    return result;
   }
+  const base = result && typeof result === 'object' ? result : {};
+  return { ...base, remaining: [...(base.remaining || []), ...extra] };
 }
 
 module.exports = {
   maybeProvisionSlackChannel,
+  maybeRegisterSlackMcpCallback,
   applySlackOnboardToCtx,
   remainingFromError
 };

package/lib/channels/slack-mcp-callback.js

@@ -0,0 +1,51 @@
+/**
+ * Allowlist Slack MCP OAuth callback on the existing customerOAuth client.
+ *
+ * @fileoverview Reuse ChatGPT Integration Client; never rotate the secret
+ */
+
+'use strict';
+
+const {
+  registerChatGptCallbackUrls,
+  chatgptProfileUrl
+} = require('./chatgpt-callback');
+const {
+  CHATGPT_INTEGRATION_CLIENT_KEY,
+  CHATGPT_OAUTH2_PROFILE_ID,
+  CHATGPT_OAUTH2_PROFILE_PATH
+} = require('./chatgpt-runtime-contract');
+const { SLACK_MCP_CALLBACK_URI } = require('./slack-mcp-runtime');
+
+const SLACK_MCP_CALLBACK_CONTRACT = {
+  integrationClientKey: CHATGPT_INTEGRATION_CLIENT_KEY,
+  oauth2ProfileId: CHATGPT_OAUTH2_PROFILE_ID,
+  oauth2ProfilePath: CHATGPT_OAUTH2_PROFILE_PATH,
+  vendorLabel: 'Slack MCP'
+};
+
+/**
+ * @param {Object} ctx
+ * @returns {string}
+ */
+function slackMcpProfileUrl(ctx) {
+  return chatgptProfileUrl(ctx, SLACK_MCP_CALLBACK_CONTRACT);
+}
+
+/**
+ * @param {Object} params
+ * @returns {Promise<Object>}
+ */
+async function registerSlackMcpCallback(params) {
+  return registerChatGptCallbackUrls({
+    ...params,
+    callbackUrls: [SLACK_MCP_CALLBACK_URI],
+    contract: SLACK_MCP_CALLBACK_CONTRACT
+  });
+}
+
+module.exports = {
+  SLACK_MCP_CALLBACK_CONTRACT,
+  slackMcpProfileUrl,
+  registerSlackMcpCallback
+};