@aifabrix/builder 2.53.1 → 2.55.0

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

@@ -10,11 +10,18 @@
 
 const crypto = require('crypto');
 const { getChannelTarget } = require('./channel-targets');
-const { normalizeSlackAppDescription } = require('./channel-description');
+const {
+  normalizeSlackAppDescription,
+  normalizeSlackAppLongDescription
+} = require('./channel-description');
 const {
   CHATGPT_RUNTIME_SYSTEM_KEY,
   CHATGPT_RUNTIME_TRANSPORT,
   CHATGPT_RUNTIME_AUTH_MODE,
+  CHATGPT_OAUTH2_PROFILE_ID,
+  CHATGPT_OAUTH2_PROFILE_PATH,
+  CHATGPT_CONNECTOR_DESCRIPTION,
+  CHATGPT_APPS_CREATE_URL,
   COPILOT_RUNTIME_SYSTEM_KEY,
   COPILOT_RUNTIME_TRANSPORT,
   COPILOT_RUNTIME_AUTH_MODE
@@ -25,8 +32,12 @@ const {
   evaluateCopilotEntraSsoReadiness
 } = require('./microsoft-copilot-entra-sso');
 const { applyCopilotEntraSsoFormFields } = require('./microsoft-copilot-entra-sso-form');
+const { applyCopilotOauthProfile, applyCopilotRuntimeDomain } = require('./channel-predefined-client');
+const { chatgptDiscoveryBlockerLabel } = require('./chatgpt-setup-values');
+const { applyMcpClientRuntimeValues } = require('./mcp-client/runtime');
+const { applyClaudeRuntimeValues } = require('./claude-runtime');
+const { applySlackMcpRuntimeValues } = require('./slack-mcp-runtime');
 
-/** Default Slack slash prefix — matches dataplane `templates/slack/command_catalog.yaml`. */
 const DEFAULT_SLACK_COMMAND_PREFIX = 'af';
 
 /**
@@ -60,33 +71,75 @@ function externalSystemsPrefix(routeSystemKey) {
 }
 
 /**
- * Relative endpoint paths per channel target (under external/systems/{routeSystemKey}).
+ * Dataplane webhook receiver prefix for inbound vendor Request URLs.
+ * @param {string} systemKey
+ * @returns {string}
+ */
+function webhooksPrefix(systemKey) {
+  return `/api/v1/webhooks/${systemKey}`;
+}
+
+/**
+ * Inbound vendor Request URLs under /api/v1/webhooks/{systemKey}/{datasourceKey}.
+ * Channel query/config FastAPI adapters are not published.
  * @param {string} channelTarget
- * @returns {Record<string, string>}
+ * @returns {{ inbound: Record<string, string>, systems: Record<string, string>, inboundSystemKey: string }}
  */
-function getEndpointPathSuffixes(channelTarget) {
+function getChannelUrlParts(channelTarget) {
   const maps = {
     slack: {
-      eventsUrl: '/events',
-      interactionUrl: '/interactive',
-      commandUrl: '/commands'
+      inboundSystemKey: 'slack',
+      inbound: {
+        eventsUrl: '/slack-events',
+        interactionUrl: '/slack-interactive',
+        commandUrl: '/slack-commands'
+      },
+      systems: {}
     },
     'teams-bot': {
-      messagesUrl: '/messages',
-      notificationsUrl: '/notifications',
-      botConfigUrl: '/bot-config'
+      inboundSystemKey: 'teams-bot',
+      inbound: {
+        messagesUrl: '/teams-bot-activities'
+      },
+      systems: {}
     },
     'microsoft-copilot': {
-      mcpUrl: '/mcp'
+      inboundSystemKey: 'microsoft-copilot',
+      inbound: {},
+      systems: { mcpUrl: '/mcp' }
     },
     chatgpt: {
-      mcpUrl: '/mcp'
+      inboundSystemKey: 'chatgpt',
+      inbound: {},
+      systems: { mcpUrl: '/mcp' }
+    },
+    claude: {
+      inboundSystemKey: 'claude',
+      inbound: {},
+      systems: { mcpUrl: '/mcp' }
+    },
+    'mcp-client': {
+      inboundSystemKey: 'mcp-client',
+      inbound: {},
+      systems: { mcpUrl: '/mcp' }
     },
     'web-embed': {
-      configUrl: '/config'
+      inboundSystemKey: 'web-embed',
+      inbound: {},
+      systems: { configUrl: '/config' }
     }
   };
-  return maps[channelTarget] || {};
+  return maps[channelTarget] || { inboundSystemKey: channelTarget, inbound: {}, systems: {} };
+}
+
+/**
+ * Relative endpoint paths per channel target (inbound + query/config suffixes).
+ * @param {string} channelTarget
+ * @returns {Record<string, string>}
+ */
+function getEndpointPathSuffixes(channelTarget) {
+  const parts = getChannelUrlParts(channelTarget);
+  return { ...parts.systems, ...parts.inbound };
 }
 
 /**
@@ -104,29 +157,45 @@ function getLegacyApiPaths(channelTarget) {
 }
 
 /**
- * Slack token rotation requires OAuth redirect URLs (api.slack.com app manifest).
- * @param {string|undefined} oauthCallbackUrl
- * @returns {{ oauthCallbackUrl?: string, slackRedirectUrlsJson: string, slackTokenRotationEnabled: boolean }}
+ * Slack HMAC inbound does not use an OAuth redirect URL.
+ * @returns {{ slackRedirectUrlsJson: string, slackTokenRotationEnabled: boolean }}
  */
-function resolveSlackOAuthManifestFields(oauthCallbackUrl) {
-  const url = typeof oauthCallbackUrl === 'string' ? oauthCallbackUrl.trim() : '';
-  if (!url) {
-    return {
-      slackRedirectUrlsJson: '[]',
-      slackTokenRotationEnabled: false
-    };
-  }
+function resolveSlackOAuthManifestFields() {
   return {
-    oauthCallbackUrl: url,
-    slackRedirectUrlsJson: JSON.stringify([url]),
-    slackTokenRotationEnabled: true
+    slackRedirectUrlsJson: '[]',
+    slackTokenRotationEnabled: false
   };
 }
 
 /**
- * @param {Object} resolved
- * @param {Object} params
+ * @param {string} [controllerUrl]
+ * @param {string} [dataplaneBaseUrl]
+ * @returns {string}
  */
+function authorizationServerBaseFromUrls(controllerUrl, dataplaneBaseUrl) {
+  const candidate = controllerUrl || dataplaneBaseUrl;
+  try {
+    return `${new URL(candidate).origin}/auth/realms/aifabrix`;
+  } catch {
+    return '';
+  }
+}
+
+function applyChatGptOAuthUrls(resolved, params) {
+  const controllerUrl = typeof params.controllerUrl === 'string' ? params.controllerUrl.trim() : '';
+  resolved.oauth2ProfileId = CHATGPT_OAUTH2_PROFILE_ID;
+  resolved.oauth2ProfilePath = CHATGPT_OAUTH2_PROFILE_PATH;
+  resolved.chatgptConnectorDescription = CHATGPT_CONNECTOR_DESCRIPTION;
+  resolved.chatgptAppsCreateUrl = CHATGPT_APPS_CREATE_URL;
+  if (controllerUrl) {
+    resolved.oauth2ProfileUrl = joinUrl(controllerUrl, CHATGPT_OAUTH2_PROFILE_PATH);
+  }
+  resolved.authorizationServerBase = authorizationServerBaseFromUrls(
+    controllerUrl,
+    resolved.dataplaneBaseUrl
+  );
+}
+
 function applyChatGptRuntimeValues(resolved, params) {
   resolved.runtimeSystemKey = CHATGPT_RUNTIME_SYSTEM_KEY;
   resolved.runtimeTransport = CHATGPT_RUNTIME_TRANSPORT;
@@ -134,6 +203,7 @@ function applyChatGptRuntimeValues(resolved, params) {
   resolved.layerBToolNames = Array.isArray(params.layerBToolNames) ? [...params.layerBToolNames] : [];
   resolved.scopes = Array.isArray(params.scopes) ? [...params.scopes] : [];
   resolved.scopesJson = JSON.stringify(resolved.scopes);
+  applyChatGptOAuthUrls(resolved, params);
 }
 
 /**
@@ -187,34 +257,18 @@ function applyDiscoveryPackageContext(resolved, packageContext) {
   resolved.discoveryAuthenticationCapabilities = packageContext.authenticationCapabilities || [];
 }
 
-/**
- * @param {Object} resolved
- * @returns {void}
- */
-function applyCopilotRuntimeDomain(resolved) {
-  resolved.runtimeDomain = '';
-  try {
-    resolved.runtimeDomain = new URL(resolved.mcpUrl).hostname;
-  } catch {
-    try {
-      resolved.runtimeDomain = new URL(resolved.dataplaneBaseUrl).hostname;
-    } catch {
-      resolved.runtimeDomain = '';
-    }
-  }
-}
-
-/**
- * @param {Object} resolved
- * @param {Object} params
- * @returns {void}
- */
 function applyCopilotPackageIdentity(resolved, params) {
   resolved.runtimeSystemKey = COPILOT_RUNTIME_SYSTEM_KEY;
   resolved.runtimeTransport = COPILOT_RUNTIME_TRANSPORT;
   resolved.runtimeAuthMode = COPILOT_RUNTIME_AUTH_MODE;
   resolved.layerBToolNames = Array.isArray(params.layerBToolNames) ? [...params.layerBToolNames] : [];
-  resolved.packageVersion = typeof params.packageVersion === 'string' ? params.packageVersion : '1.0.0';
+  if (typeof params.packageVersion === 'string' && params.packageVersion.trim()) {
+    resolved.packageVersion = params.packageVersion.trim();
+    resolved.packageVersionExplicit = true;
+  } else {
+    resolved.packageVersion = '1.0.0';
+    resolved.packageVersionExplicit = false;
+  }
   resolved.packageAppId = buildDeterministicGuid(
     `${resolved.channelTarget}:${resolved.baseName}:${resolved.environment}:app`
   );
@@ -240,7 +294,8 @@ function applyMicrosoftCopilotRuntimeValues(resolved, params) {
   resolved.scopes = resolveCopilotEntraScopes({
     explicitScopes: params.scopes,
     packageContext: params.packageContext,
-    entraProvider: params.entraProvider
+    entraProvider: params.entraProvider,
+    entraIdentityProvider: params.entraIdentityProvider
   });
   resolved.scopesJson = JSON.stringify(resolved.scopes);
   const readiness = evaluateCopilotEntraSsoReadiness({
@@ -264,6 +319,7 @@ function applyMicrosoftCopilotRuntimeValues(resolved, params) {
   applyCopilotRuntimeDomain(resolved);
   applyCopilotEntraSsoFormFields(resolved, params);
   applyMicrosoftCopilotDisplayLimits(resolved);
+  applyCopilotOauthProfile(resolved, params);
 }
 
 /**
@@ -289,18 +345,52 @@ function applyResolvedPaths(resolved, base, systemPrefix, suffixes, legacy) {
  * @param {Object} params
  */
 function applySlackRuntimeValues(resolved, params) {
-  const oauthCallbackUrl = params.oauthCallbackUrl || resolved.oauthCallbackUrl;
-  Object.assign(resolved, resolveSlackOAuthManifestFields(oauthCallbackUrl));
+  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()
+      : '1.0.0';
+  const appLongDescription = normalizeSlackAppLongDescription(params.appDescription);
+  resolved.appLongDescription = appLongDescription;
+  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
+ * @returns {string}
+ */
+function normalizeSlackCommandPrefix(raw) {
   const prefix =
-    typeof params.commandPrefix === 'string' && params.commandPrefix.trim()
-      ? params.commandPrefix.trim()
+    typeof raw === 'string' && raw.trim()
+      ? raw.trim().toLowerCase()
       : DEFAULT_SLACK_COMMAND_PREFIX;
-  resolved.commandPrefix = prefix;
+  if (!/^[a-z][a-z0-9]{0,15}$/.test(prefix)) {
+    throw new Error(
+      'Invalid --command-prefix. Use 1–16 letters or digits starting with a letter (for example af6).'
+    );
+  }
+  return prefix;
 }
 
 /**
  * @param {Object} params
  * @param {string} params.dataplaneBaseUrl
+ * @param {string} [params.controllerUrl] Miso Controller base URL (ChatGPT OAuth2 profile link)
  * @param {string} params.channelTarget
  * @param {string} params.appName
  * @param {string} [params.baseName]
@@ -313,15 +403,19 @@ function applySlackRuntimeValues(resolved, params) {
 function resolveChannelRuntimeValues(params) {
   const target = getChannelTarget(params.channelTarget);
   const base = normalizeBaseUrl(params.dataplaneBaseUrl);
-  const routeKey = target.routeSystemKey || target.key;
-  const systemPrefix = externalSystemsPrefix(routeKey);
-  const suffixes = getEndpointPathSuffixes(params.channelTarget);
+  const instanceKey = params.instanceSystemKey || params.channelTarget;
+  const runtimeKey =
+    (target.runtimeTarget && target.runtimeTarget.defaultSystemKey) || 'runtime-orchestration';
+  const systemPrefix = externalSystemsPrefix(runtimeKey);
+  const urlParts = getChannelUrlParts(params.channelTarget);
   const legacy = getLegacyApiPaths(params.channelTarget);
 
   const resolved = {
     dataplaneBaseUrl: base,
     channelTarget: params.channelTarget,
-    routeSystemKey: routeKey,
+    routeSystemKey: runtimeKey,
+    instanceSystemKey: instanceKey,
+    runtimeSystemKey: runtimeKey,
     appName: params.appName,
     baseName: params.baseName || params.appName,
     environment: params.environment || 'dev',
@@ -331,46 +425,74 @@ function resolveChannelRuntimeValues(params) {
         : params.appDescription,
     icon: params.icon || '',
     credentialKey: target.credentialKey,
-    credentialPortalUrl: joinUrl(base, `/connected-systems/${params.channelTarget}?tab=authentication`),
+    credentialPortalUrl: joinUrl(base, `/connected-systems/${instanceKey}?tab=authentication`),
     assistantCatalogUrl: joinUrl(base, '/api/v1/workers/available'),
     scopes: []
   };
 
-  applyResolvedPaths(resolved, base, systemPrefix, suffixes, legacy);
+  applyResolvedPaths(resolved, base, systemPrefix, urlParts.systems, legacy);
+  applyResolvedPaths(
+    resolved,
+    base,
+    webhooksPrefix(instanceKey),
+    urlParts.inbound,
+    {}
+  );
+
+  applyChannelSpecificRuntime(resolved, params);
+  return resolved;
+}
 
+/**
+ * @param {Object} resolved
+ * @param {Object} params
+ */
+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);
   }
-
   if (params.channelTarget === 'chatgpt') {
     applyChatGptRuntimeValues(resolved, params);
     applyDiscoveryPackageContext(resolved, params.packageContext);
+    resolved.discoveryBlockerLabel = chatgptDiscoveryBlockerLabel(resolved.discoveryBlocker);
+  }
+  if (params.channelTarget === 'claude') {
+    applyClaudeRuntimeValues(resolved, params);
+    applyDiscoveryPackageContext(resolved, params.packageContext);
+    resolved.discoveryBlockerLabel = chatgptDiscoveryBlockerLabel(resolved.discoveryBlocker);
+  }
+  if (params.channelTarget === 'mcp-client') {
+    applyMcpClientRuntimeValues(resolved, params);
+    applyDiscoveryPackageContext(resolved, params.packageContext);
+    resolved.discoveryBlockerLabel = chatgptDiscoveryBlockerLabel(resolved.discoveryBlocker);
   }
-
   if (params.channelTarget === 'teams-bot') {
     applyDiscoveryPackageContext(resolved, params.packageContext);
   }
-
-  return resolved;
 }
 
 module.exports = {
   normalizeBaseUrl,
   joinUrl,
   externalSystemsPrefix,
+  webhooksPrefix,
   getEndpointPathSuffixes,
+  getChannelUrlParts,
   buildDeterministicGuid,
   applyResolvedPaths,
   applySlackRuntimeValues,
   applyMicrosoftCopilotRuntimeValues,
   applyChatGptRuntimeValues,
+  applyClaudeRuntimeValues,
+  applyMcpClientRuntimeValues,
   applyDiscoveryPackageContext,
   resolveSlackOAuthManifestFields,
   resolveChannelRuntimeValues,
-  DEFAULT_SLACK_COMMAND_PREFIX
+  DEFAULT_SLACK_COMMAND_PREFIX,
+  normalizeSlackCommandPrefix
 };

package/lib/channels/channel-status-display.js

@@ -17,6 +17,7 @@ const {
   sectionTitle,
   metadata
 } = require('../utils/cli-test-layout-chalk');
+const { CHANNEL_TARGETS } = require('./channel-targets');
 
 /** @returns {string} */
 function separatorLine() {
@@ -46,17 +47,27 @@ function displayApprovalGuideOptionalLinks(approvalGuide) {
   }
 }
 
+/**
+ * @param {Object} approvalGuide
+ * @returns {string}
+ */
+function approvalGuideHeading(approvalGuide) {
+  if (approvalGuide.approvalRequired === false) {
+    return 'Go-live steps';
+  }
+  if (typeof approvalGuide.heading === 'string' && approvalGuide.heading.trim()) {
+    return approvalGuide.heading.trim();
+  }
+  return 'Workspace admin setup required';
+}
+
 /**
  * @param {Object|null} approvalGuide
  */
 function displayApprovalGuideSection(approvalGuide) {
   if (!approvalGuide?.steps?.length) return;
   logger.log('');
-  const heading =
-    approvalGuide.approvalRequired === false
-      ? 'Go-live steps'
-      : 'Organisation publish / Teams admin approval required';
-  logger.log(formatWarningLine(heading));
+  logger.log(formatWarningLine(approvalGuideHeading(approvalGuide)));
   if (approvalGuide.portalUrl) {
     logger.log(metadata('Developer Portal:'));
     logger.log(chalk.cyan(approvalGuide.portalUrl));
@@ -103,6 +114,31 @@ function displayExistingChannelStatus(params) {
   logger.log(separatorLine());
 }
 
+/**
+ * @param {Object} result
+ */
+function displayChannelPackagePaths(result) {
+  if (result.artifactPath) {
+    logger.log(metadata(`Artifact: ${result.artifactPath}`));
+  }
+  if (result.installGuidePath) {
+    logger.log(metadata(`Install guide (README): ${result.installGuidePath}`));
+  }
+  if (result.zipPath) {
+    logger.log(metadata(`Package ZIP: ${result.zipPath}`));
+  }
+  if (!result.packageVersion) {
+    return;
+  }
+  if (result.priorPackageVersion && result.priorPackageVersion !== result.packageVersion) {
+    logger.log(
+      metadata(`Package version: ${result.priorPackageVersion} → ${result.packageVersion}`)
+    );
+    return;
+  }
+  logger.log(metadata(`Package version: ${result.packageVersion}`));
+}
+
 /**
  * @param {Object} result
  */
@@ -121,16 +157,26 @@ function displayChannelCoreFields(result) {
       logger.log(`  - ${cap}`);
     }
   }
-  if (result.artifactPath) {
-    logger.log(metadata(`Artifact: ${result.artifactPath}`));
-  }
-  if (result.installGuidePath) {
-    logger.log(metadata(`Install guide (README): ${result.installGuidePath}`));
+  displayChannelPackagePaths(result);
+  displayReadinessLines(result);
+  displayRemainingManualStep(result.channelTarget);
+}
+
+/**
+ * Concise remaining vendor-owned step from the channel registry.
+ * @param {string} channelTarget
+ * @returns {void}
+ */
+function displayRemainingManualStep(channelTarget) {
+  if (channelTarget === 'chatgpt' || channelTarget === 'claude') {
+    return;
   }
-  if (result.zipPath) {
-    logger.log(metadata(`Package ZIP: ${result.zipPath}`));
+  const step = CHANNEL_TARGETS[channelTarget] && CHANNEL_TARGETS[channelTarget].remainingManualStep;
+  if (!step) {
+    return;
   }
-  displayReadinessLines(result);
+  logger.log('');
+  logger.log(formatWarningLine(`Remaining vendor step: ${step}`));
 }
 
 /**
@@ -149,13 +195,16 @@ function displayReadinessLines(result) {
   } else if (result.installReady === false) {
     logger.log(metadata('Package / Runtime ready: no'));
   }
-  if (result.microsoftPublicationPending === true) {
+  if (result.channelTarget === 'microsoft-copilot' && result.microsoftPublicationPending === true) {
     logger.log(
       metadata(
         'Microsoft publication: pending (Developer Portal import → Publish to your org → Teams admin approval)'
       )
     );
-  } else if (result.microsoftPublicationPending === false) {
+  } else if (
+    result.channelTarget === 'microsoft-copilot' &&
+    result.microsoftPublicationPending === false
+  ) {
     logger.log(metadata('Microsoft publication: cleared'));
   } else if (result.installReady === false && result.blocker && !packageBlocker) {
     logger.log(metadata(`Install ready: no (${result.blocker})`));
@@ -231,9 +280,29 @@ function displayRuntimeChecks(runtimeChecks) {
  * @param {Object} result
  */
 function displayApprovalSection(result) {
+  if (result.channelTarget === 'chatgpt' || result.channelTarget === 'claude') {
+    return;
+  }
   displayApprovalGuideSection(result.approvalGuide);
 }
 
+/**
+ * Microsoft org-publication is Copilot-only. ChatGPT must not inherit that flag.
+ * @param {string} channelTarget
+ * @param {Object} artifact
+ * @param {string} status
+ * @returns {boolean|undefined}
+ */
+function microsoftPublicationPendingForDisplay(channelTarget, artifact, status) {
+  if (channelTarget !== 'microsoft-copilot') {
+    return undefined;
+  }
+  if (artifact.microsoftPublicationPending !== undefined) {
+    return artifact.microsoftPublicationPending;
+  }
+  return status === 'approvalRequired';
+}
+
 /**
  * @param {Object} result
  */
@@ -254,5 +323,6 @@ function displayChannelError(message) {
 module.exports = {
   displayExistingChannelStatus,
   displayChannelInstallResult,
-  displayChannelError
+  displayChannelError,
+  microsoftPublicationPendingForDisplay
 };