@aifabrix/builder 2.52.0 → 2.52.1

package/lib/channels/approval-guides/microsoft-copilot.js

@@ -1,14 +1,16 @@
 /**
- * Microsoft Copilot channel admin approval steps (plan 152).
+ * Microsoft Copilot channel install / approval steps.
  *
- * @fileoverview Copilot Studio / M365 admin connector guide
+ * @fileoverview Teams custom-app upload guide aligned with install templates
  * @author AI Fabrix Team
  * @version 1.0.0
  */
 
 'use strict';
 
-const { formatCredentialPortalStep } = require('./credential-portal');
+const {
+  ENTRA_SSO_REGISTRATION_URL
+} = require('../microsoft-copilot-entra-sso-form');
 
 /**
  * @param {Object} ctx
@@ -16,16 +18,18 @@ const { formatCredentialPortalStep } = require('./credential-portal');
  */
 function buildMicrosoftCopilotApprovalGuide(ctx) {
   return {
-    portalUrl: 'https://admin.cloud.microsoft.com/',
+    portalUrl: ENTRA_SSO_REGISTRATION_URL,
     steps: [
-      'Sign in to Microsoft 365 admin (https://admin.cloud.microsoft.com/) or Copilot Studio as a tenant admin.',
-      'Upload or sideload the generated appPackage.<env>.zip package artifact.',
-      'Review declarative agent + Remote MCP plugin details and approve tenant distribution.',
-      'Configure Entra/OAuth consent and user assignment for target groups.',
-      formatCredentialPortalStep(ctx, 'Copilot channel credential references (no secrets in package files)'),
-      'Verify Runtime MCP endpoint and Layer B tool visibility using INSTALL.md guidance.',
-      `After Copilot shows the package as available, re-run: ${ctx.resumeCommand}`,
-      'Optional: use --probe for AI Fabrix-side checks; tenant upload/approval remains Microsoft-admin responsibility.'
+      'Open Microsoft Teams with your target Microsoft 365 account.',
+      'Go to Apps → Manage your apps → Upload an app → Upload a custom app.',
+      'Upload only appPackage.<env>.zip (do not upload individual manifest files or channel-microsoft-copilot.json).',
+      'Review permissions, select Add, and open the installed app. Users stay on the Microsoft 365 Entra session — no separate AI Fabrix sign-in.',
+      'If prompted, complete Entra admin consent for the Runtime MCP delegated scope.',
+      'If Upload a custom app is unavailable, ask a Teams admin to enable custom app uploads or deploy the package centrally.',
+      `Register Entra SSO first at ${ENTRA_SSO_REGISTRATION_URL} using the Base URL / Client ID / Scope values printed by the CLI (or INSTALL.md). Pass the registration id as --oauth-plugin-vault-reference-id.`,
+      'Do not configure AI Fabrix OAuth client secrets under Connected Systems → Authentication for this Entra SSO flow.',
+      'Confirm Runtime MCP and governed tools using INSTALL.md, then re-run with --probe after Teams install.',
+      `After the app is available in Teams, re-run: ${ctx.resumeCommand}`
     ]
   };
 }

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

@@ -0,0 +1,128 @@
+/**
+ * Ensure local scaffold + dataplane upload before channel add install.
+ *
+ * @fileoverview One-command channel add prelude (scaffold → upload if needed)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { formatSuccessLine, metadata } = require('../utils/cli-test-layout-chalk');
+const { getIntegrationPath } = require('../utils/paths');
+const { getExternalSystem } = require('../api/external-systems.api');
+const { unwrapApiData } = require('../utils/external-system-readiness-core');
+const { scaffoldChannelIntegration } = require('./channel-integration-generator');
+const { resolveChannelAuthContext } = require('./channel-auth-context');
+const { uploadExternalSystem } = require('../commands/upload');
+
+/**
+ * @param {string} channelTarget
+ * @param {string} [projectRoot]
+ * @returns {string}
+ */
+function resolveIntegrationDir(channelTarget, projectRoot) {
+  if (projectRoot) {
+    return path.join(path.resolve(projectRoot), 'integration', channelTarget);
+  }
+  return getIntegrationPath(channelTarget);
+}
+
+/**
+ * @param {Object} ctx
+ * @param {string} channelTarget
+ * @returns {Promise<boolean>}
+ */
+async function isCommunicationSystemUploaded(ctx, channelTarget) {
+  const res = await getExternalSystem(ctx.dataplaneUrl, channelTarget, ctx.authConfig);
+  const system = unwrapApiData(res);
+  return !!(system && typeof system === 'object');
+}
+
+/**
+ * Scaffold integration/<target>/ when missing (does not overwrite).
+ *
+ * @param {string} channelTarget
+ * @param {Object} options
+ * @returns {Promise<{ scaffolded: boolean, integrationDir: string }>}
+ */
+async function ensureChannelScaffold(channelTarget, options = {}) {
+  const integrationDir = resolveIntegrationDir(channelTarget, options.projectRoot);
+  if (fs.existsSync(integrationDir)) {
+    return { scaffolded: false, integrationDir };
+  }
+  const result = await scaffoldChannelIntegration(channelTarget, {
+    projectRoot: options.projectRoot,
+    allowExperimental: options.allowExperimental === true
+  });
+  if (options.quiet !== true) {
+    logger.log(formatSuccessLine(`Scaffolded integration at ${result.integrationDir}`));
+    for (const file of result.files) {
+      logger.log(metadata(file));
+    }
+  }
+  return { scaffolded: true, integrationDir: result.integrationDir };
+}
+
+/**
+ * Upload when missing on dataplane; with --force upload every time.
+ *
+ * @param {string} channelTarget
+ * @param {Object} options
+ * @returns {Promise<{ uploaded: boolean, skipped: boolean, ctx: Object|null }>}
+ */
+async function ensureChannelUploaded(channelTarget, options = {}) {
+  if (options.dryRun === true) {
+    return { uploaded: false, skipped: true, ctx: null };
+  }
+  const ctx = await resolveChannelAuthContext(channelTarget, { silent: options.quiet === true });
+  const force = options.force === true;
+  const alreadyUploaded = force ? false : await isCommunicationSystemUploaded(ctx, channelTarget);
+  if (alreadyUploaded) {
+    if (options.quiet !== true) {
+      logger.log(chalk.gray(`  Communication system "${channelTarget}" already on dataplane`));
+    }
+    return { uploaded: false, skipped: true, ctx };
+  }
+  if (options.quiet !== true) {
+    const reason = force ? 'force upload' : 'not found on dataplane';
+    logger.log(chalk.white(`Uploading ${channelTarget} (${reason})…`));
+  }
+  await uploadExternalSystem(channelTarget, {
+    force: true,
+    minimal: options.quiet === true || options.minimal !== false
+  });
+  if (options.quiet !== true) {
+    logger.log(formatSuccessLine(`Uploaded ${channelTarget}`));
+  }
+  return { uploaded: true, skipped: false, ctx };
+}
+
+/**
+ * Scaffold if needed, then upload if missing (or always when --force).
+ *
+ * @param {string} channelTarget
+ * @param {Object} options
+ * @returns {Promise<{ scaffolded: boolean, uploaded: boolean, integrationDir: string }>}
+ */
+async function ensureChannelReadyForAdd(channelTarget, options = {}) {
+  const scaffold = await ensureChannelScaffold(channelTarget, options);
+  const upload = await ensureChannelUploaded(channelTarget, options);
+  return {
+    scaffolded: scaffold.scaffolded,
+    uploaded: upload.uploaded,
+    integrationDir: scaffold.integrationDir
+  };
+}
+
+module.exports = {
+  resolveIntegrationDir,
+  isCommunicationSystemUploaded,
+  ensureChannelScaffold,
+  ensureChannelUploaded,
+  ensureChannelReadyForAdd
+};

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

@@ -147,11 +147,21 @@ function generateChannelArtifact(params) {
     params.dryRun === true
   );
 
+  const installReady = params.runtimeValues?.installReady === true;
+  const blocker = params.runtimeValues?.discoveryBlocker || null;
   return {
     outputPath,
     artifactHash,
     content,
-    installPath: install?.installPath
+    installPath: install?.installPath,
+    zipPath: null,
+    links: {
+      readme: install?.installPath || null,
+      zip: null,
+      filesRoot: outputDir
+    },
+    installReady,
+    blocker
   };
 }
 

package/lib/channels/channel-branding.js

@@ -0,0 +1,94 @@
+/**
+ * Optional channel package branding in Builder workspace (plan 167.0).
+ *
+ * @fileoverview Read/write channel-branding.json under integration/<systemKey>/
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('../internal/fs-real-sync');
+const path = require('path');
+
+const BRANDING_FILENAME = 'channel-branding.json';
+
+/**
+ * @param {string} workspaceSystemDir
+ * @returns {string}
+ */
+function brandingFilePath(workspaceSystemDir) {
+  return path.join(workspaceSystemDir, BRANDING_FILENAME);
+}
+
+/**
+ * @param {string} workspaceSystemDir
+ * @returns {{ displayName?: string, description?: string, iconColorPath?: string, iconOutlinePath?: string }}
+ */
+function readChannelBranding(workspaceSystemDir) {
+  const filePath = brandingFilePath(workspaceSystemDir);
+  if (!fs.existsSync(filePath)) {
+    return {};
+  }
+  const raw = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  if (!raw || typeof raw !== 'object') {
+    return {};
+  }
+  /** @type {{ displayName?: string, description?: string, iconColorPath?: string, iconOutlinePath?: string }} */
+  const out = {};
+  if (typeof raw.displayName === 'string' && raw.displayName.trim()) {
+    out.displayName = raw.displayName.trim();
+  }
+  if (typeof raw.description === 'string' && raw.description.trim()) {
+    out.description = raw.description.trim();
+  }
+  if (typeof raw.iconColorPath === 'string' && raw.iconColorPath.trim()) {
+    out.iconColorPath = raw.iconColorPath.trim();
+  }
+  if (typeof raw.iconOutlinePath === 'string' && raw.iconOutlinePath.trim()) {
+    out.iconOutlinePath = raw.iconOutlinePath.trim();
+  }
+  return out;
+}
+
+/**
+ * @param {string} workspaceSystemDir
+ * @param {Object} branding
+ * @returns {Object}
+ */
+function writeChannelBranding(workspaceSystemDir, branding) {
+  fs.mkdirSync(workspaceSystemDir, { recursive: true });
+  const next = {
+    ...readChannelBranding(workspaceSystemDir),
+    ...(branding && typeof branding === 'object' ? branding : {})
+  };
+  const cleaned = {};
+  for (const key of ['displayName', 'description', 'iconColorPath', 'iconOutlinePath']) {
+    if (typeof next[key] === 'string' && next[key].trim()) {
+      cleaned[key] = next[key].trim();
+    }
+  }
+  fs.writeFileSync(brandingFilePath(workspaceSystemDir), `${JSON.stringify(cleaned, null, 2)}\n`, 'utf8');
+  return cleaned;
+}
+
+/**
+ * Merge CLI/API overrides over workspace branding.
+ * @param {Object} [workspaceBranding]
+ * @param {Object} [overrides]
+ * @returns {Object}
+ */
+function mergeChannelBranding(workspaceBranding, overrides) {
+  return {
+    ...(workspaceBranding && typeof workspaceBranding === 'object' ? workspaceBranding : {}),
+    ...(overrides && typeof overrides === 'object' ? overrides : {})
+  };
+}
+
+module.exports = {
+  BRANDING_FILENAME,
+  brandingFilePath,
+  readChannelBranding,
+  writeChannelBranding,
+  mergeChannelBranding
+};

package/lib/channels/channel-credential.js

@@ -18,6 +18,7 @@ const {
   auditCredentialUpdated,
   auditFailed
 } = require('./channel-audit');
+const { skipsChannelOauthCredential } = require('./microsoft-copilot-entra-sso');
 
 /** @type {Record<string, { method: string, displayName: string, credentialConfig: Object }>} */
 const CREDENTIAL_SPECS = {
@@ -171,6 +172,13 @@ async function pushIntegrationSecrets(ctx, channelTarget) {
  */
 async function ensureChannelCredential(params) {
   const { ctx, channelTarget, target, force = false } = params;
+  if (skipsChannelOauthCredential(channelTarget)) {
+    return {
+      skipped: true,
+      reason: 'entraSsoTrustedIssuer',
+      credentialKey: target.credentialKey
+    };
+  }
   const existing = await findCredentialByKey(ctx, target.credentialKey);
   if (existing) {
     auditCredentialUpdated(channelTarget, {

package/lib/channels/channel-discovery.js

@@ -0,0 +1,330 @@
+/**
+ * External AI Discovery mapping for channel packaging (plan 167.0).
+ *
+ * @fileoverview Pure discovery → package context; optional Dataplane fetch
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { ApiClient } = require('../api');
+const { RUNTIME_ORCHESTRATION_SYSTEM_KEY } = require('./chatgpt-runtime-contract');
+const { normalizeBaseUrl, joinUrl } = require('./channel-runtime-resolver');
+
+const GATEWAY_TOOLS_CATALOG_MARKER = '/api/v1/mcp/servers/tools';
+
+/**
+ * @param {string} pathOrUrl
+ * @returns {boolean}
+ */
+function isGatewayToolsCatalogUrl(pathOrUrl) {
+  const value = String(pathOrUrl || '');
+  return value.includes(GATEWAY_TOOLS_CATALOG_MARKER);
+}
+
+/**
+ * Normalize discovery paths that include a public `/data` prefix.
+ * @param {string} dataplaneBaseUrl
+ * @param {string|null|undefined} pathOrUrl
+ * @returns {string|null}
+ */
+function resolveDiscoveryUrl(dataplaneBaseUrl, pathOrUrl) {
+  if (!pathOrUrl || typeof pathOrUrl !== 'string') {
+    return null;
+  }
+  const trimmed = pathOrUrl.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (isGatewayToolsCatalogUrl(trimmed)) {
+    throw new Error(
+      'Gateway tools catalog must not be used as MCP server URL for channel packages'
+    );
+  }
+  if (/^https?:\/\//i.test(trimmed)) {
+    return trimmed;
+  }
+  let relative = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+  if (relative.startsWith('/data/api/')) {
+    relative = relative.slice('/data'.length);
+  }
+  return joinUrl(normalizeBaseUrl(dataplaneBaseUrl), relative);
+}
+
+/**
+ * @param {Object} discovery
+ * @param {string} key
+ * @returns {Object|null}
+ */
+function findEntryPoint(discovery, key) {
+  const entries = Array.isArray(discovery?.entryPoints) ? discovery.entryPoints : [];
+  return entries.find((ep) => ep && ep.key === key) || null;
+}
+
+/**
+ * @param {Object} discovery
+ * @returns {string[]}
+ */
+function extractGovernedToolNames(discovery) {
+  const fromRuntime = discovery?.runtimeDiscovery?.governedToolNames;
+  if (Array.isArray(fromRuntime) && fromRuntime.length > 0) {
+    return fromRuntime.map((name) => String(name)).filter(Boolean);
+  }
+  const tools = Array.isArray(discovery?.tools) ? discovery.tools : [];
+  return tools.map((tool) => (tool && tool.name ? String(tool.name) : '')).filter(Boolean);
+}
+
+/**
+ * @param {Object} discovery
+ * @param {Object|null} adapter
+ * @param {string} dataplaneBaseUrl
+ * @returns {{ mcpServerUrl: string|null, installReady: boolean, blocker: string|null }}
+ */
+function resolveMcpConnection(discovery, adapter, dataplaneBaseUrl) {
+  const adapterUrl = adapter?.connection?.mcpServerUrl || null;
+  const remote = findEntryPoint(discovery, 'remoteMcp');
+  const fromEntry =
+    resolveDiscoveryUrl(dataplaneBaseUrl, remote?.absoluteUrl) ||
+    resolveDiscoveryUrl(dataplaneBaseUrl, remote?.path);
+  const mcpServerUrl = resolveDiscoveryUrl(dataplaneBaseUrl, adapterUrl) || fromEntry;
+  if (mcpServerUrl && isGatewayToolsCatalogUrl(mcpServerUrl)) {
+    throw new Error(
+      'Gateway tools catalog must not be used as MCP server URL for channel packages'
+    );
+  }
+  const mcpReady = discovery?.publication?.mcpReady === true;
+  const connectable = adapter ? adapter.connectable === true : mcpReady;
+  const remoteAvailable = discovery?.transport?.remoteMcp?.status === 'available';
+  const installReady = Boolean(mcpReady && connectable && remoteAvailable && mcpServerUrl);
+  const blocker =
+    adapter?.blocker ||
+    (!installReady ? 'remoteMcpUnavailable' : null);
+  return { mcpServerUrl, installReady, blocker };
+}
+
+/**
+ * @param {Object} branding
+ * @param {Object} identity
+ * @param {Object|null} adapter
+ * @returns {string}
+ */
+function resolvePackageDisplayName(branding, identity, adapter) {
+  if (typeof branding.displayName === 'string' && branding.displayName.trim()) {
+    return branding.displayName.trim();
+  }
+  return (
+    identity.displayName ||
+    adapter?.nameForHuman ||
+    adapter?.displayName ||
+    identity.systemKey ||
+    RUNTIME_ORCHESTRATION_SYSTEM_KEY
+  );
+}
+
+/**
+ * @param {Object} branding
+ * @param {Object} identity
+ * @param {Object|null} adapter
+ * @param {Object} discovery
+ * @returns {string}
+ */
+function resolvePackageDescription(branding, identity, adapter, discovery) {
+  if (typeof branding.description === 'string' && branding.description.trim()) {
+    return branding.description.trim();
+  }
+  return (
+    identity.description ||
+    adapter?.descriptionForHuman ||
+    adapter?.description ||
+    discovery.operatingModel?.summary ||
+    ''
+  );
+}
+
+/**
+ * @param {Object|null} auth
+ * @returns {Object|null}
+ */
+function mapAdapterAuthentication(auth) {
+  if (!auth) return null;
+  return {
+    recommendedCapability: auth.recommendedCapability || null,
+    issuer: auth.issuer || null,
+    openidConfigurationUrl: auth.openidConfigurationUrl || null,
+    authorizationServerMetadataUrl: auth.authorizationServerMetadataUrl || null,
+    protectedResourceMetadataUrl: auth.protectedResourceMetadataUrl || null,
+    resource: auth.resource || auth.apiResource || null,
+    audience: auth.audience !== undefined && auth.audience !== null ? auth.audience : null,
+    scopes: Array.isArray(auth.scopes)
+      ? [...auth.scopes]
+      : Array.isArray(auth.allowedScopes)
+        ? [...auth.allowedScopes]
+        : [],
+    operatorNote: auth.operatorNote || null,
+    pkceRequired: auth.pkceRequired === true,
+    clientRegistrationModes: Array.isArray(auth.clientRegistrationModes)
+      ? [...auth.clientRegistrationModes]
+      : []
+  };
+}
+
+/**
+ * @param {Object} branding
+ * @returns {boolean}
+ */
+function isBrandingApplied(branding) {
+  return Boolean(
+    (branding.displayName && String(branding.displayName).trim()) ||
+      (branding.description && String(branding.description).trim())
+  );
+}
+
+/**
+ * Map discovery (+ optional adapter) into packaging fields.
+ *
+ * @param {Object} params
+ * @param {Object} params.discovery
+ * @param {Object} [params.adapter]
+ * @param {string} params.dataplaneBaseUrl
+ * @param {Object} [params.branding]
+ * @returns {Object}
+ */
+function mapDiscoveryToPackageContext(params) {
+  const discovery = params.discovery;
+  if (!discovery || typeof discovery !== 'object') {
+    throw new Error('discovery document is required');
+  }
+  const identity = discovery.identity || {};
+  const branding = params.branding && typeof params.branding === 'object' ? params.branding : {};
+  const adapter = params.adapter || null;
+  const connection = resolveMcpConnection(discovery, adapter, params.dataplaneBaseUrl);
+  const authCaps = Array.isArray(discovery.authenticationCapabilities)
+    ? discovery.authenticationCapabilities.map((c) => c.capability || c).filter(Boolean)
+    : [];
+  return {
+    systemKey: identity.systemKey || RUNTIME_ORCHESTRATION_SYSTEM_KEY,
+    displayName: resolvePackageDisplayName(branding, identity, adapter),
+    description: resolvePackageDescription(branding, identity, adapter, discovery),
+    governedToolNames: extractGovernedToolNames(discovery),
+    mcpServerUrl: connection.mcpServerUrl,
+    installReady: connection.installReady,
+    blocker: connection.blocker,
+    authentication: mapAdapterAuthentication(adapter?.authentication || null),
+    authenticationCapabilities: authCaps,
+    publication: {
+      mcpReady: discovery.publication?.mcpReady === true,
+      environment: discovery.publication?.environment || null
+    },
+    brandingApplied: isBrandingApplied(branding)
+  };
+}
+
+/**
+ * @param {Object} response
+ * @returns {Object}
+ */
+function unwrapApiData(response) {
+  if (response && typeof response === 'object' && response.data && typeof response.data === 'object') {
+    if (response.data.kind || response.data.identity || response.data.adapter) {
+      return response.data;
+    }
+  }
+  return response;
+}
+
+/**
+ * @param {string} dataplaneBaseUrl
+ * @param {Object} authConfig
+ * @param {string} [systemKey]
+ * @returns {Promise<Object>}
+ */
+async function fetchExternalAiDiscovery(
+  dataplaneBaseUrl,
+  authConfig,
+  systemKey = RUNTIME_ORCHESTRATION_SYSTEM_KEY
+) {
+  const client = new ApiClient(normalizeBaseUrl(dataplaneBaseUrl), authConfig || {});
+  const response = await client.get(`/api/v1/external/systems/${systemKey}/discovery`);
+  const discovery = unwrapApiData(response);
+  if (!discovery || !discovery.kind) {
+    throw new Error(`Discovery document missing for systemKey=${systemKey}`);
+  }
+  return discovery;
+}
+
+/**
+ * @param {string} dataplaneBaseUrl
+ * @param {Object} authConfig
+ * @param {string} adapterKey microsoft-plugin | chatgpt-setup
+ * @param {string} [systemKey]
+ * @returns {Promise<Object>}
+ */
+async function fetchExternalAiDiscoveryAdapter(
+  dataplaneBaseUrl,
+  authConfig,
+  adapterKey,
+  systemKey = RUNTIME_ORCHESTRATION_SYSTEM_KEY
+) {
+  const client = new ApiClient(normalizeBaseUrl(dataplaneBaseUrl), authConfig || {});
+  const response = await client.get(
+    `/api/v1/external/systems/${systemKey}/discovery/adapters/${adapterKey}`
+  );
+  return unwrapApiData(response);
+}
+
+/**
+ * @param {string} channelTarget
+ * @returns {string|null}
+ */
+function adapterKeyForChannel(channelTarget) {
+  if (channelTarget === 'microsoft-copilot') return 'microsoft-plugin';
+  if (channelTarget === 'chatgpt') return 'chatgpt-setup';
+  return null;
+}
+
+/**
+ * Fetch discovery (+ adapter when known) and map package context.
+ *
+ * @param {Object} params
+ * @returns {Promise<Object>}
+ */
+async function loadChannelPackageContext(params) {
+  const systemKey = params.runtimeSystemKey || RUNTIME_ORCHESTRATION_SYSTEM_KEY;
+  const discovery = await fetchExternalAiDiscovery(
+    params.dataplaneBaseUrl,
+    params.authConfig,
+    systemKey
+  );
+  const adapterKey = adapterKeyForChannel(params.channelTarget);
+  let adapter = null;
+  if (adapterKey) {
+    try {
+      adapter = await fetchExternalAiDiscoveryAdapter(
+        params.dataplaneBaseUrl,
+        params.authConfig,
+        adapterKey,
+        systemKey
+      );
+    } catch {
+      adapter = null;
+    }
+  }
+  return mapDiscoveryToPackageContext({
+    discovery,
+    adapter,
+    dataplaneBaseUrl: params.dataplaneBaseUrl,
+    branding: params.branding
+  });
+}
+
+module.exports = {
+  GATEWAY_TOOLS_CATALOG_MARKER,
+  isGatewayToolsCatalogUrl,
+  resolveDiscoveryUrl,
+  mapDiscoveryToPackageContext,
+  fetchExternalAiDiscovery,
+  fetchExternalAiDiscoveryAdapter,
+  adapterKeyForChannel,
+  loadChannelPackageContext
+};

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

@@ -72,7 +72,7 @@ async function fetchCommunicationSystem(ctx) {
   if (!system || typeof system !== 'object') {
     throw new Error(
       `Communication external system "${ctx.channelTarget}" was not found. ` +
-        `Run: aifabrix deploy ${ctx.channelTarget}`
+        `Run: aifabrix channel add ${ctx.channelTarget} --name "…" --force`
     );
   }
   const kind = system.systemKind || system.systemKindKey;