@aifabrix/builder 2.53.1 → 2.55.0

package/lib/channels/channel-targets.js

@@ -1,92 +1,84 @@
 /**
- * Channel target registry for assistant communication channels (plan 152).
+ * Channel target registry projected from Channel Definitions.
  *
- * @fileoverview Channel install targets — templates, capabilities, approval semantics
+ * @fileoverview CHANNEL_TARGETS is a projection of templates/channels/<key>/channel.json
  * @author AI Fabrix Team
- * @version 1.0.0
+ * @version 1.2.0
  */
 
 'use strict';
 
 const {
-  CHATGPT_RUNTIME_SYSTEM_KEY,
-  COPILOT_RUNTIME_SYSTEM_KEY
-} = require('./chatgpt-runtime-contract');
+  getChannelDefinition,
+  getChannelDefinitionMap,
+  listChannelDefinitionKeys
+} = require('./channel-definition-registry');
+const { toChannelTargetProjection } = require('./channel-definition-project');
+const {
+  assertChannelStatusInstallable,
+  channelStatusOf,
+  isCatalogHiddenStatus,
+  isInstallableStatus
+} = require('./channel-definition-status');
 
-/** @typedef {'teams-bot'|'slack'|'microsoft-copilot'|'chatgpt'|'web-embed'} ChannelTargetKey */
+function buildChannelTargets() {
+  const targets = {};
+  for (const [key, definition] of getChannelDefinitionMap().entries()) {
+    targets[key] = toChannelTargetProjection(definition);
+  }
+  return targets;
+}
 
-const DEFAULT_CAPABILITIES = ['chat', 'notify', 'documentApproval'];
+/** @type {Record<string, Object>|null} */
+let cachedChannelTargets = null;
 
-const CHANNEL_TARGETS = {
-  'teams-bot': {
-    key: 'teams-bot',
-    channelType: 'teamsBot',
-    templateDir: 'teams-bot',
-    artifactFileName: 'channel-teams-bot.json',
-    artifactFormat: 'json',
-    credentialKey: 'teams-bot',
-    routeSystemKey: 'teams',
-    capabilities: DEFAULT_CAPABILITIES,
-    approvalRequired: true,
-    experimental: false
-  },
-  slack: {
-    key: 'slack',
-    channelType: 'slack',
-    templateDir: 'slack',
-    artifactFileName: 'channel-slack.json',
-    artifactFormat: 'json',
-    credentialKey: 'slack-app',
-    routeSystemKey: 'slack',
-    capabilities: DEFAULT_CAPABILITIES,
-    approvalRequired: true,
-    experimental: false
-  },
-  'microsoft-copilot': {
-    key: 'microsoft-copilot',
-    channelType: 'microsoftCopilot',
-    templateDir: 'microsoft-copilot',
-    artifactFileName: 'channel-microsoft-copilot.json',
-    artifactFormat: 'json',
-    credentialKey: 'microsoft-copilot-channel',
-    routeSystemKey: COPILOT_RUNTIME_SYSTEM_KEY,
-    capabilities: [...DEFAULT_CAPABILITIES, 'enterpriseActions'],
-    approvalRequired: true,
-    experimental: false
-  },
-  chatgpt: {
-    key: 'chatgpt',
-    channelType: 'chatgpt',
-    templateDir: 'chatgpt',
-    artifactFileName: 'channel-chatgpt.json',
-    artifactFormat: 'json',
-    credentialKey: 'chatgpt-channel',
-    routeSystemKey: CHATGPT_RUNTIME_SYSTEM_KEY,
-    capabilities: ['chat', 'enterpriseActions'],
-    approvalRequired: true,
-    experimental: false
-  },
-  'web-embed': {
-    key: 'web-embed',
-    channelType: 'webEmbed',
-    templateDir: 'web-embed',
-    artifactFileName: 'channel-web-embed.json',
-    artifactFormat: 'json',
-    credentialKey: 'web-embed-channel',
-    capabilities: DEFAULT_CAPABILITIES,
-    approvalRequired: false,
-    experimental: true
+function resolveChannelTargets() {
+  if (cachedChannelTargets && Object.keys(cachedChannelTargets).length > 0) {
+    return cachedChannelTargets;
   }
-};
-
-const CHANNEL_TARGET_KEYS = Object.keys(CHANNEL_TARGETS);
+  cachedChannelTargets = buildChannelTargets();
+  return cachedChannelTargets;
+}
 
 /**
  * @param {string} channelTarget
  * @returns {boolean}
  */
 function isChannelTargetKey(channelTarget) {
-  return typeof channelTarget === 'string' && CHANNEL_TARGET_KEYS.includes(channelTarget);
+  return typeof channelTarget === 'string' && channelTarget in resolveChannelTargets();
+}
+
+/**
+ * Human-readable supported channel list for CLI help and error hints.
+ * @returns {string}
+ */
+function formatSupportedChannelTargetsHelp() {
+  const targets = resolveChannelTargets();
+  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');
+}
+
+/**
+ * @param {string} channelTarget
+ * @returns {string}
+ */
+function formatUnknownChannelTargetError(channelTarget) {
+  const live = listLiveChannelTargetKeys().join(', ');
+  return `Unknown channel: ${channelTarget}\nLive channels: ${live}`;
 }
 
 /**
@@ -95,11 +87,64 @@ function isChannelTargetKey(channelTarget) {
  */
 function getChannelTarget(channelTarget) {
   if (!isChannelTargetKey(channelTarget)) {
+    throw new Error(formatUnknownChannelTargetError(channelTarget));
+  }
+  return resolveChannelTargets()[channelTarget];
+}
+
+/**
+ * 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]
+ * @returns {{ name: string, value: string }[]}
+ */
+function listWizardChannelChoices(options = {}) {
+  const targets = resolveChannelTargets();
+  return listInstallableChannelTargetKeys(options)
+    .map((key) => targets[key])
+    .sort((a, b) => (a.wizardOrder || 100) - (b.wizardOrder || 100))
+    .map((target) => ({ name: target.displayLabel, value: target.key }));
+}
+
+/**
+ * Reject experimental targets unless `--allow-experimental` is set.
+ * @param {string} channelTarget
+ * @param {{ allowExperimental?: boolean }} [options]
+ * @returns {typeof CHANNEL_TARGETS[string]}
+ */
+function assertChannelTargetInstallable(channelTarget, options = {}) {
+  const target = getChannelTarget(channelTarget);
+  assertChannelStatusInstallable(channelTarget, options);
+  if (target.experimental && options.allowExperimental !== true) {
     throw new Error(
-      `Unknown channel target "${channelTarget}". Expected one of: ${CHANNEL_TARGET_KEYS.join(', ')}`
+      `Channel target "${channelTarget}" is experimental. Pass --allow-experimental to install.`
     );
   }
-  return CHANNEL_TARGETS[channelTarget];
+  return target;
 }
 
 /**
@@ -113,27 +158,22 @@ function getDefaultChannelDescription() {
   );
 }
 
-/**
- * Human-readable supported channel list for CLI help and error hints.
- * @returns {string}
- */
-function formatSupportedChannelTargetsHelp() {
-  const stable = CHANNEL_TARGET_KEYS.filter((key) => !CHANNEL_TARGETS[key].experimental);
-  const experimental = CHANNEL_TARGET_KEYS.filter((key) => CHANNEL_TARGETS[key].experimental);
-  const lines = ['Supported channels:', `  ${stable.join(', ')}`];
-  if (experimental.length > 0) {
-    lines.push(
-      `  ${experimental.join(', ')} (experimental — scaffold with --allow-experimental)`
-    );
-  }
-  return lines.join('\n');
-}
-
 module.exports = {
-  CHANNEL_TARGETS,
-  CHANNEL_TARGET_KEYS,
+  get CHANNEL_TARGETS() {
+    return resolveChannelTargets();
+  },
+  get CHANNEL_TARGET_KEYS() {
+    return Object.keys(resolveChannelTargets());
+  },
   isChannelTargetKey,
   getChannelTarget,
   getDefaultChannelDescription,
-  formatSupportedChannelTargetsHelp
+  formatSupportedChannelTargetsHelp,
+  formatUnknownChannelTargetError,
+  listLiveChannelTargetKeys,
+  listInstallableChannelTargetKeys,
+  listWizardChannelChoices,
+  assertChannelTargetInstallable,
+  getChannelDefinition,
+  listChannelDefinitionKeys
 };

package/lib/channels/chatgpt-callback.js

@@ -0,0 +1,318 @@
+/**
+ * Register ChatGPT callback URLs on the existing chatgpt Integration Client.
+ *
+ * Never rotates the client secret. Catalog sync is additive — extra URIs stay.
+ *
+ * @fileoverview HTTPS callback validation + idempotent redirect URI merge
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const {
+  listIntegrationClients,
+  getIntegrationClient,
+  updateIntegrationClientRedirectUris
+} = require('../api/integration-clients.api');
+const {
+  CHATGPT_INTEGRATION_CLIENT_KEY,
+  CHATGPT_OAUTH2_PROFILE_ID,
+  CHATGPT_OAUTH2_PROFILE_PATH
+} = require('./chatgpt-runtime-contract');
+
+const CHATGPT_CALLBACK_CONTRACT = {
+  integrationClientKey: CHATGPT_INTEGRATION_CLIENT_KEY,
+  oauth2ProfileId: CHATGPT_OAUTH2_PROFILE_ID,
+  oauth2ProfilePath: CHATGPT_OAUTH2_PROFILE_PATH,
+  vendorLabel: 'ChatGPT'
+};
+
+/**
+ * @param {Object|null|undefined} contract
+ * @returns {typeof CHATGPT_CALLBACK_CONTRACT}
+ */
+function resolveCallbackContract(contract) {
+  return {
+    integrationClientKey: (contract && contract.integrationClientKey) || CHATGPT_CALLBACK_CONTRACT.integrationClientKey,
+    oauth2ProfileId: (contract && contract.oauth2ProfileId) || CHATGPT_CALLBACK_CONTRACT.oauth2ProfileId,
+    oauth2ProfilePath: (contract && contract.oauth2ProfilePath) || CHATGPT_CALLBACK_CONTRACT.oauth2ProfilePath,
+    vendorLabel: (contract && contract.vendorLabel) || CHATGPT_CALLBACK_CONTRACT.vendorLabel
+  };
+}
+
+/**
+ * @param {string} message
+ * @param {string} [boundary]
+ * @param {Object} [contract]
+ * @returns {Error}
+ */
+function createChatGptCallbackError(message, boundary, contract) {
+  const resolved = resolveCallbackContract(contract);
+  const error = new Error(`${resolved.vendorLabel} callback: ${message}`);
+  error.boundary = boundary || 'callback';
+  return error;
+}
+
+/**
+ * @param {string|undefined} value
+ * @returns {string}
+ */
+function assertHttpsRedirectUri(value, contract) {
+  const trimmed = typeof value === 'string' ? value.trim() : '';
+  if (!trimmed) {
+    throw createChatGptCallbackError('Callback URL is required.', 'callback', contract);
+  }
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    throw createChatGptCallbackError(`Callback URL is not a valid URL: ${trimmed}`, 'callback', contract);
+  }
+  if (parsed.protocol !== 'https:') {
+    throw createChatGptCallbackError(`Callback URL must be HTTPS: ${trimmed}`, 'callback', contract);
+  }
+  return trimmed;
+}
+
+/**
+ * @param {string[]|undefined} existing
+ * @param {string} nextUri
+ * @returns {{ uris: string[], added: boolean }}
+ */
+function mergeRedirectUris(existing, nextUri) {
+  const list = Array.isArray(existing)
+    ? existing.filter((uri) => typeof uri === 'string' && uri.trim())
+    : [];
+  if (list.some((uri) => uri.trim() === nextUri)) {
+    return { uris: list, added: false };
+  }
+  return { uris: [...list, nextUri], added: true };
+}
+
+/**
+ * @param {string[]|undefined} existing
+ * @param {string[]} nextUris
+ * @returns {{ uris: string[], added: boolean }}
+ */
+function mergeRedirectUriList(existing, nextUris) {
+  let uris = Array.isArray(existing) ? [...existing] : [];
+  let added = false;
+  for (const nextUri of nextUris) {
+    const merged = mergeRedirectUris(uris, nextUri);
+    uris = merged.uris;
+    added = added || merged.added;
+  }
+  return { uris, added };
+}
+
+/**
+ * @param {string[]|undefined} values
+ * @returns {string[]}
+ */
+function normalizeCallbackUrls(values, contract) {
+  const unique = [];
+  for (const value of Array.isArray(values) ? values : []) {
+    const uri = assertHttpsRedirectUri(value, contract);
+    if (!unique.includes(uri)) {
+      unique.push(uri);
+    }
+  }
+  if (unique.length === 0) {
+    throw createChatGptCallbackError('Callback URL is required.', 'callback', contract);
+  }
+  return unique;
+}
+
+/**
+ * @param {Object} response
+ * @returns {Object|Array}
+ */
+function unwrapApiBody(response) {
+  if (response && response.data && response.data.data !== undefined && response.data.data !== null) {
+    return response.data.data;
+  }
+  if (response && response.data !== undefined) {
+    return response.data;
+  }
+  return response || {};
+}
+
+/**
+ * @param {Object} response
+ * @returns {Array}
+ */
+function unwrapIntegrationClientList(response) {
+  const body = unwrapApiBody(response);
+  if (Array.isArray(body)) {
+    return body;
+  }
+  if (Array.isArray(body.data)) {
+    return body.data;
+  }
+  if (Array.isArray(body.items)) {
+    return body.items;
+  }
+  return [];
+}
+
+/**
+ * @param {Object} response
+ * @returns {Object}
+ */
+function unwrapIntegrationClientRecord(response) {
+  const body = unwrapApiBody(response);
+  return body.integrationClient || body;
+}
+
+/**
+ * @param {Object} ctx
+ * @param {Object} [contract]
+ * @returns {string}
+ */
+function chatgptProfileUrl(ctx, contract) {
+  const resolved = resolveCallbackContract(contract);
+  const base = ctx && typeof ctx.controllerUrl === 'string' ? ctx.controllerUrl.replace(/\/$/, '') : '';
+  if (!base) {
+    return resolved.oauth2ProfilePath;
+  }
+  return `${base}${resolved.oauth2ProfilePath}`;
+}
+
+/**
+ * @param {Object} ctx
+ * @param {Object} [contract]
+ * @returns {string}
+ */
+function formatMissingChatGptClientError(ctx, contract) {
+  const resolved = resolveCallbackContract(contract);
+  return [
+    `Integration client "${resolved.integrationClientKey}" was not found.`,
+    `Open the ${resolved.vendorLabel} OAuth2 profile (${resolved.oauth2ProfileId}): ${chatgptProfileUrl(ctx, resolved)}`,
+    `Enable the ${resolved.vendorLabel} profile, then retry callback registration.`
+  ].join(' ');
+}
+
+/**
+ * @param {Error|Object} errorOrResponse
+ * @returns {boolean}
+ */
+function isForbiddenClientError(errorOrResponse) {
+  const status = errorOrResponse && errorOrResponse.status;
+  if (status === 403) {
+    return true;
+  }
+  const message = errorOrResponse && errorOrResponse.message
+    ? String(errorOrResponse.message)
+    : '';
+  return /\b403\b/.test(message) || /forbidden|not allowed|integration-client:update/i.test(message);
+}
+
+/**
+ * @param {Object} ctx
+ * @param {Object} [deps]
+ * @returns {Promise<Object>}
+ */
+async function findChatGptIntegrationClient(ctx, deps = {}) {
+  const contract = resolveCallbackContract(deps.contract);
+  const listFn = deps.listIntegrationClients || listIntegrationClients;
+  const getFn = deps.getIntegrationClient || getIntegrationClient;
+  const response = await listFn(ctx.controllerUrl, ctx.authConfig, { pageSize: 100 });
+  if (response && response.success === false) {
+    throw createChatGptCallbackError(
+      response.formattedError || response.error || 'Failed to list integration clients.',
+      response.status === 403 ? 'permissions' : 'callback',
+      contract
+    );
+  }
+  const match = unwrapIntegrationClientList(response).find(
+    (row) => row && row.key === contract.integrationClientKey
+  );
+  if (!match || !match.id) {
+    throw createChatGptCallbackError(formatMissingChatGptClientError(ctx, contract), 'callback', contract);
+  }
+  const detail = await getFn(ctx.controllerUrl, ctx.authConfig, match.id);
+  const record = unwrapIntegrationClientRecord(detail);
+  return { ...match, ...record, id: match.id };
+}
+
+/**
+ * @param {Object} params
+ * @param {Object} client
+ * @param {string[]} uris
+ * @returns {Promise<Object|null>}
+ */
+async function applyRedirectUriUpdate(params, client, uris) {
+  const contract = resolveCallbackContract(params.contract);
+  const updateFn = params.updateRedirectUris || updateIntegrationClientRedirectUris;
+  try {
+    const response = await updateFn(params.ctx.controllerUrl, params.ctx.authConfig, client.id, {
+      redirectUris: uris
+    });
+    if (response && response.success === false && response.status === 403) {
+      return { ok: false, fallback: true, profileUrl: chatgptProfileUrl(params.ctx, contract) };
+    }
+    if (response && response.success === false) {
+      throw createChatGptCallbackError(
+        response.formattedError || response.error || 'Failed to update redirect URIs.',
+        'callback',
+        contract
+      );
+    }
+  } catch (error) {
+    if (isForbiddenClientError(error)) {
+      return { ok: false, fallback: true, profileUrl: chatgptProfileUrl(params.ctx, contract) };
+    }
+    throw error;
+  }
+  return null;
+}
+
+/**
+ * Idempotent HTTPS callback registration. Never rotates secrets.
+ * @param {Object} params
+ * @returns {Promise<{ ok: boolean, added?: boolean, fallback?: boolean, profileUrl?: string, redirectUris?: string[] }>}
+ */
+async function registerChatGptCallbackUrls(params) {
+  const contract = resolveCallbackContract(params.contract);
+  const callbackUrls = normalizeCallbackUrls(params.callbackUrls, contract);
+  let client;
+  try {
+    client = await findChatGptIntegrationClient(params.ctx, { ...params, contract });
+  } catch (error) {
+    if (isForbiddenClientError(error)) {
+      return { ok: false, fallback: true, profileUrl: chatgptProfileUrl(params.ctx, contract) };
+    }
+    throw error;
+  }
+  const merged = mergeRedirectUriList(client.redirectUris, callbackUrls);
+  const forbidden = await applyRedirectUriUpdate(params, client, merged.uris);
+  if (forbidden) {
+    return forbidden;
+  }
+  return { ok: true, added: merged.added, redirectUris: merged.uris };
+}
+
+/**
+ * @param {Object} params
+ * @returns {Promise<Object>}
+ */
+async function registerChatGptCallbackUrl(params) {
+  return registerChatGptCallbackUrls({
+    ...params,
+    callbackUrls: [params.callbackUrl]
+  });
+}
+
+module.exports = {
+  assertHttpsRedirectUri,
+  mergeRedirectUris,
+  unwrapIntegrationClientList,
+  findChatGptIntegrationClient,
+  formatMissingChatGptClientError,
+  registerChatGptCallbackUrl,
+  registerChatGptCallbackUrls,
+  chatgptProfileUrl,
+  resolveCallbackContract,
+  CHATGPT_CALLBACK_CONTRACT
+};