@aifabrix/builder 2.53.1 → 2.55.0

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

@@ -0,0 +1,124 @@
+/**
+ * Customer-facing ChatGPT form values: Name, Description, Server URL, OAuth.
+ * Discovery may still resolve authorization/token endpoints internally.
+ * Never invent Keycloak paths or tell admins to copy from a Miso profile.
+ *
+ * @fileoverview ChatGPT channel form values — describe, don't configure
+ * @author AI Fabrix Team
+ * @version 1.1.0
+ */
+
+'use strict';
+
+const {
+  CHATGPT_OAUTH2_PROFILE_ID,
+  CHATGPT_OAUTH2_PROFILE_PATH,
+  CHATGPT_APPS_CREATE_URL
+} = require('./chatgpt-runtime-contract');
+const { getDefaultChannelDescription } = require('./channel-targets');
+
+const CHATGPT_AUTHENTICATION = 'OAuth';
+
+/**
+ * @param {Object|null|undefined} integrationClient
+ * @returns {string}
+ */
+function resolveChatGptClientId(integrationClient) {
+  const fromClient =
+    integrationClient && typeof integrationClient.keycloakClientId === 'string'
+      ? integrationClient.keycloakClientId.trim()
+      : '';
+  return fromClient || CHATGPT_OAUTH2_PROFILE_ID;
+}
+
+/**
+ * Prefer live discovery endpoints; never fall back to invented realm paths.
+ * @param {Object|null|undefined} asMetadata
+ * @param {string} field
+ * @returns {string|null}
+ */
+function discoveryEndpoint(asMetadata, field) {
+  const value = asMetadata && asMetadata[field];
+  if (typeof value !== 'string' || !value.trim()) {
+    return null;
+  }
+  return value.trim();
+}
+
+/**
+ * @param {Object} params
+ * @param {Object} params.runtimeValues
+ * @param {Object|null} [params.integrationClient]
+ * @param {Object|null} [params.asMetadata]
+ * @returns {Object}
+ */
+function buildChatGptFormValues(params) {
+  const runtimeValues = params.runtimeValues || {};
+  const asMetadata = params.asMetadata || null;
+  const authorizationUrl = discoveryEndpoint(asMetadata, 'authorization_endpoint');
+  const tokenUrl = discoveryEndpoint(asMetadata, 'token_endpoint');
+  const oauth2ProfileUrl =
+    typeof runtimeValues.oauth2ProfileUrl === 'string' ? runtimeValues.oauth2ProfileUrl : '';
+  return {
+    name: runtimeValues.appName || runtimeValues.baseName || '',
+    description:
+      (typeof runtimeValues.appDescription === 'string' && runtimeValues.appDescription.trim()) ||
+      getDefaultChannelDescription(),
+    connection: 'Server URL',
+    serverUrl: runtimeValues.mcpUrl || '',
+    authentication: CHATGPT_AUTHENTICATION,
+    clientId: resolveChatGptClientId(params.integrationClient),
+    authorizationUrl,
+    tokenUrl,
+    oauth2ProfileId: CHATGPT_OAUTH2_PROFILE_ID,
+    oauth2ProfilePath: CHATGPT_OAUTH2_PROFILE_PATH,
+    oauth2ProfileUrl,
+    appsCreateUrl: CHATGPT_APPS_CREATE_URL
+  };
+}
+
+/**
+ * @param {Object} values
+ * @returns {string[]}
+ */
+function formatChatGptFormValueLines(values) {
+  const lines = [];
+  if (values.name) {
+    lines.push(`Name: ${values.name}`);
+  }
+  if (values.description) {
+    lines.push(`Description: ${values.description}`);
+  }
+  if (values.serverUrl) {
+    lines.push(`Server URL: ${values.serverUrl}`);
+  }
+  if (values.authentication) {
+    lines.push(`Authentication: ${values.authentication}`);
+  }
+  return lines;
+}
+
+/**
+ * @param {string|null|undefined} blocker
+ * @returns {string}
+ */
+function chatgptDiscoveryBlockerLabel(blocker) {
+  if (blocker === 'remoteMcpUnavailable') {
+    return 'Runtime MCP endpoint is unavailable.';
+  }
+  if (blocker === 'discoveryUnavailable') {
+    return 'Runtime discovery is unavailable.';
+  }
+  if (typeof blocker === 'string' && blocker.trim()) {
+    return blocker.trim();
+  }
+  return 'Runtime is not ready.';
+}
+
+module.exports = {
+  CHATGPT_APPS_CREATE_URL,
+  resolveChatGptClientId,
+  buildChatGptFormValues,
+  formatChatGptFormValueLines,
+  chatgptDiscoveryBlockerLabel
+};

package/lib/channels/claude-callback.js

@@ -0,0 +1,67 @@
+/**
+ * Register Claude callback URLs on the existing claude Integration Client.
+ *
+ * @fileoverview Thin ChatGPT-callback wrapper with the Claude OAuth contract
+ */
+
+'use strict';
+
+const {
+  registerChatGptCallbackUrl,
+  registerChatGptCallbackUrls,
+  findChatGptIntegrationClient,
+  chatgptProfileUrl
+} = require('./chatgpt-callback');
+const {
+  CLAUDE_INTEGRATION_CLIENT_KEY,
+  CLAUDE_OAUTH2_PROFILE_ID,
+  CLAUDE_OAUTH2_PROFILE_PATH
+} = require('./claude-runtime-contract');
+
+const CLAUDE_CALLBACK_CONTRACT = {
+  integrationClientKey: CLAUDE_INTEGRATION_CLIENT_KEY,
+  oauth2ProfileId: CLAUDE_OAUTH2_PROFILE_ID,
+  oauth2ProfilePath: CLAUDE_OAUTH2_PROFILE_PATH,
+  vendorLabel: 'Claude'
+};
+
+/**
+ * @param {Object} ctx
+ * @returns {string}
+ */
+function claudeProfileUrl(ctx) {
+  return chatgptProfileUrl(ctx, CLAUDE_CALLBACK_CONTRACT);
+}
+
+/**
+ * @param {Object} ctx
+ * @param {Object} [deps]
+ * @returns {Promise<Object>}
+ */
+async function findClaudeIntegrationClient(ctx, deps = {}) {
+  return findChatGptIntegrationClient(ctx, { ...deps, contract: CLAUDE_CALLBACK_CONTRACT });
+}
+
+/**
+ * @param {Object} params
+ * @returns {Promise<Object>}
+ */
+async function registerClaudeCallbackUrls(params) {
+  return registerChatGptCallbackUrls({ ...params, contract: CLAUDE_CALLBACK_CONTRACT });
+}
+
+/**
+ * @param {Object} params
+ * @returns {Promise<Object>}
+ */
+async function registerClaudeCallbackUrl(params) {
+  return registerChatGptCallbackUrl({ ...params, contract: CLAUDE_CALLBACK_CONTRACT });
+}
+
+module.exports = {
+  CLAUDE_CALLBACK_CONTRACT,
+  claudeProfileUrl,
+  findClaudeIntegrationClient,
+  registerClaudeCallbackUrl,
+  registerClaudeCallbackUrls
+};

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

@@ -0,0 +1,254 @@
+/**
+ * Claude continuation for channel add: preflight, form values, callback PUT.
+ *
+ * @fileoverview Keep add-channel.js free of Claude-specific continuation logic
+ */
+
+'use strict';
+
+const {
+  printValidating,
+  printRuntimeDeployed,
+  printRuntimeUnavailable,
+  printOAuthConnected,
+  printOAuthNotConnected,
+  printLabeledUrl,
+  printUseLines,
+  printRemainingSteps,
+  printFixThenRerun
+} = require('./channel-add-tty');
+const { formatWarningLine } = require('../utils/cli-layout-chalk');
+const logger = require('../utils/logger');
+const { runChatGptPreflight } = require('./chatgpt-preflight');
+const {
+  buildClaudeFormValues,
+  formatClaudeFormValueLines,
+  CLAUDE_CONNECTORS_URL
+} = require('./claude-setup-values');
+const {
+  registerClaudeCallbackUrls,
+  findClaudeIntegrationClient,
+  claudeProfileUrl
+} = require('./claude-callback');
+const { CLAUDE_KNOWN_CALLBACK_URIS, CLAUDE_REMAINING_STEPS } = require('./claude-runtime-contract');
+const { resolveChannelRuntimeValues } = require('./channel-runtime-resolver');
+const { vendorFacingUrlsFromCtx } = require('./vendor-dataplane-url');
+const { loadChannelPackageContext } = require('./channel-discovery');
+
+/**
+ * @param {string} message
+ * @returns {string}
+ */
+function claudePreflightMessage(message) {
+  return String(message || '').replace(/^ChatGPT preflight:\s*/i, 'Claude preflight: ');
+}
+
+/**
+ * @param {Error} error
+ * @returns {boolean}
+ */
+function isClaudeOAuthPreflightError(error) {
+  const message = error && error.message ? String(error.message) : '';
+  return /pkce|authorization.server|protected resource/i.test(message);
+}
+
+/**
+ * @param {Object} params
+ * @returns {string}
+ */
+function claudeResumeCommand(params) {
+  const name =
+    (params.options && params.options.name) ||
+    (params.runtimeValues && (params.runtimeValues.baseName || params.runtimeValues.appName)) ||
+    '';
+  const quoted = name ? `"${name}"` : '"<name>"';
+  return `aifabrix channel add claude --name ${quoted}`;
+}
+
+/**
+ * @param {Object} params
+ * @param {Error} error
+ * @returns {void}
+ */
+function printClaudePreflightFailure(params, error) {
+  if (isClaudeOAuthPreflightError(error)) {
+    printRuntimeDeployed();
+    printOAuthNotConnected();
+    printFixThenRerun('Fix OAuth discovery', claudeResumeCommand(params));
+    return;
+  }
+  printRuntimeUnavailable();
+  printFixThenRerun('Fix the Runtime connection', claudeResumeCommand(params));
+}
+
+/**
+ * Fail-closed MCP/OAuth checks before Claude instructions.
+ * @param {Object} params
+ * @returns {Promise<Object|null>}
+ */
+async function maybeAssertClaudePreflight(params) {
+  if (params.channelTarget !== 'claude') {
+    return null;
+  }
+  printValidating('Claude');
+  try {
+    params.preflight = await runChatGptPreflight(params);
+    printRuntimeDeployed();
+    if (!(params.preflight && params.preflight.skipped)) {
+      printOAuthConnected();
+    }
+    return params.preflight;
+  } catch (error) {
+    if (error && error.message) {
+      error.message = claudePreflightMessage(error.message);
+    }
+    printClaudePreflightFailure(params, error);
+    throw error;
+  }
+}
+
+/**
+ * @param {Object} ctx
+ * @returns {Promise<Object|null>}
+ */
+async function loadClaudeClientOrNull(ctx) {
+  try {
+    return await findClaudeIntegrationClient(ctx);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {Object} values
+ * @returns {void}
+ */
+function printClaudeFormValues(values) {
+  printLabeledUrl('Open Claude connectors', CLAUDE_CONNECTORS_URL);
+  printUseLines(formatClaudeFormValueLines(values));
+}
+
+/**
+ * @param {Object} options
+ * @returns {string[]}
+ */
+function callbackUrlsForAdd(options = {}) {
+  const urls = [...CLAUDE_KNOWN_CALLBACK_URIS];
+  const extra = typeof options.callbackUrl === 'string' ? options.callbackUrl.trim() : '';
+  if (extra && !urls.includes(extra)) {
+    urls.push(extra);
+  }
+  return urls;
+}
+
+/**
+ * @param {Object} result
+ * @param {Object} ctx
+ * @returns {void}
+ */
+function printClaudeCallbackResult(result, ctx) {
+  if (!result.fallback) {
+    return;
+  }
+  logger.log(
+    formatWarningLine(
+      `Missing integration-client:update. Add the callback on the Claude profile: ${result.profileUrl || claudeProfileUrl(ctx)}`
+    )
+  );
+}
+
+/**
+ * Remaining Anthropic-owned steps after AI Fabrix prep.
+ * @returns {void}
+ */
+function printClaudeRemainingSteps() {
+  printRemainingSteps('Claude', CLAUDE_REMAINING_STEPS);
+}
+
+/**
+ * @param {Object} params
+ * @returns {Promise<void>}
+ */
+async function runClaudeChannelAddContinuation(params) {
+  const preflight = params.preflight || (await runChatGptPreflight(params));
+  const client = await loadClaudeClientOrNull(params.ctx);
+  const values = buildClaudeFormValues({
+    runtimeValues: params.runtimeValues,
+    integrationClient: client,
+    asMetadata: preflight && preflight.asMetadata
+  });
+  printClaudeFormValues(values);
+  const result = await registerClaudeCallbackUrls({
+    ctx: params.ctx,
+    callbackUrls: callbackUrlsForAdd(params.options)
+  });
+  printClaudeCallbackResult(result, params.ctx);
+  printClaudeRemainingSteps();
+}
+
+/**
+ * @param {Object} params
+ * @returns {Promise<void>}
+ */
+async function maybeRunClaudeContinuation(params) {
+  if (params.channelTarget !== 'claude') {
+    return;
+  }
+  await runClaudeChannelAddContinuation(params);
+}
+
+/**
+ * After callback PUT: re-validate Runtime and OAuth.
+ * @param {Object} ctx
+ * @returns {Promise<void>}
+ */
+async function runClaudeConfigureValidate(ctx) {
+  let packageContext = null;
+  try {
+    packageContext = await loadChannelPackageContext({
+      dataplaneBaseUrl: ctx.dataplaneUrl,
+      authConfig: ctx.authConfig,
+      channelTarget: 'claude'
+    });
+  } catch {
+    packageContext = null;
+  }
+  const vendor = vendorFacingUrlsFromCtx(ctx);
+  const runtimeValues = resolveChannelRuntimeValues({
+    dataplaneBaseUrl: vendor.dataplaneBaseUrl,
+    controllerUrl: vendor.controllerUrl,
+    channelTarget: 'claude',
+    appName: 'Claude',
+    environment: ctx.environment,
+    packageContext
+  });
+  await maybeAssertClaudePreflight({
+    channelTarget: 'claude',
+    runtimeValues,
+    ctx,
+    options: {}
+  });
+}
+
+/**
+ * Dry-run TTY: no live OAuth.
+ * @param {Object} params
+ * @returns {void}
+ */
+function printClaudeDryRunTty(params) {
+  printValidating('Claude');
+  printRuntimeDeployed();
+  const values = buildClaudeFormValues({ runtimeValues: params.runtimeValues || {} });
+  printLabeledUrl('Open Claude connectors', CLAUDE_CONNECTORS_URL);
+  printUseLines(formatClaudeFormValueLines(values));
+  printRemainingSteps('Claude', CLAUDE_REMAINING_STEPS);
+}
+
+module.exports = {
+  maybeAssertClaudePreflight,
+  maybeRunClaudeContinuation,
+  runClaudeChannelAddContinuation,
+  runClaudeConfigureValidate,
+  printClaudeDryRunTty,
+  callbackUrlsForAdd
+};

package/lib/channels/claude-runtime-contract.js

@@ -0,0 +1,40 @@
+/**
+ * Claude custom connector runtime contract constants (plan 178.0).
+ *
+ * @fileoverview Runtime MCP + Anthropic connector URLs used by the claude channel
+ */
+
+'use strict';
+
+const {
+  RUNTIME_ORCHESTRATION_SYSTEM_KEY,
+  CHATGPT_RUNTIME_TRANSPORT,
+  CHATGPT_RUNTIME_AUTH_MODE
+} = require('./chatgpt-runtime-contract');
+
+const CLAUDE_RUNTIME_SYSTEM_KEY = RUNTIME_ORCHESTRATION_SYSTEM_KEY;
+const CLAUDE_RUNTIME_TRANSPORT = CHATGPT_RUNTIME_TRANSPORT;
+const CLAUDE_RUNTIME_AUTH_MODE = CHATGPT_RUNTIME_AUTH_MODE;
+const CLAUDE_OAUTH2_PROFILE_ID = 'miso-claude';
+const CLAUDE_OAUTH2_PROFILE_PATH = '/external-access/oauth2-profiles/miso-claude';
+const CLAUDE_INTEGRATION_CLIENT_KEY = 'claude';
+const CLAUDE_CONNECTORS_URL = 'https://claude.ai/new#settings/customize-connectors';
+const CLAUDE_CALLBACK_URI = 'https://claude.ai/api/mcp/auth_callback';
+const CLAUDE_KNOWN_CALLBACK_URIS = [CLAUDE_CALLBACK_URI];
+const CLAUDE_CONNECTOR_DESCRIPTION =
+  'Use governed enterprise work tools only. Resolve Role Assistants dynamically and keep business reasoning inside authorized Role Assistant boundaries.';
+const CLAUDE_REMAINING_STEPS = [];
+
+module.exports = {
+  CLAUDE_RUNTIME_SYSTEM_KEY,
+  CLAUDE_RUNTIME_TRANSPORT,
+  CLAUDE_RUNTIME_AUTH_MODE,
+  CLAUDE_OAUTH2_PROFILE_ID,
+  CLAUDE_OAUTH2_PROFILE_PATH,
+  CLAUDE_INTEGRATION_CLIENT_KEY,
+  CLAUDE_CONNECTORS_URL,
+  CLAUDE_CALLBACK_URI,
+  CLAUDE_KNOWN_CALLBACK_URIS,
+  CLAUDE_CONNECTOR_DESCRIPTION,
+  CLAUDE_REMAINING_STEPS
+};

package/lib/channels/claude-runtime.js

@@ -0,0 +1,58 @@
+/**
+ * Runtime values for the Claude custom-connector channel.
+ *
+ * @fileoverview Same Runtime MCP as ChatGPT; Claude OAuth profile and connector URL
+ */
+
+'use strict';
+
+const {
+  CLAUDE_RUNTIME_SYSTEM_KEY,
+  CLAUDE_RUNTIME_TRANSPORT,
+  CLAUDE_RUNTIME_AUTH_MODE,
+  CLAUDE_OAUTH2_PROFILE_ID,
+  CLAUDE_OAUTH2_PROFILE_PATH,
+  CLAUDE_CONNECTORS_URL,
+  CLAUDE_CONNECTOR_DESCRIPTION
+} = require('./claude-runtime-contract');
+
+/**
+ * @param {string} [controllerUrl]
+ * @param {string} [dataplaneBaseUrl]
+ * @returns {string}
+ */
+function authorizationServerBase(controllerUrl, dataplaneBaseUrl) {
+  const candidate = controllerUrl || dataplaneBaseUrl;
+  try {
+    return `${new URL(candidate).origin}/auth/realms/aifabrix`;
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * @param {Object} resolved
+ * @param {Object} params
+ * @returns {void}
+ */
+function applyClaudeRuntimeValues(resolved, params) {
+  resolved.runtimeSystemKey = CLAUDE_RUNTIME_SYSTEM_KEY;
+  resolved.runtimeTransport = CLAUDE_RUNTIME_TRANSPORT;
+  resolved.runtimeAuthMode = CLAUDE_RUNTIME_AUTH_MODE;
+  resolved.layerBToolNames = Array.isArray(params.layerBToolNames) ? [...params.layerBToolNames] : [];
+  resolved.scopes = Array.isArray(params.scopes) ? [...params.scopes] : [];
+  resolved.scopesJson = JSON.stringify(resolved.scopes);
+  resolved.oauth2ProfileId = CLAUDE_OAUTH2_PROFILE_ID;
+  resolved.oauth2ProfilePath = CLAUDE_OAUTH2_PROFILE_PATH;
+  resolved.claudeConnectorDescription = CLAUDE_CONNECTOR_DESCRIPTION;
+  resolved.claudeConnectorsUrl = CLAUDE_CONNECTORS_URL;
+  const controllerUrl = typeof params.controllerUrl === 'string' ? params.controllerUrl.trim() : '';
+  if (controllerUrl) {
+    resolved.oauth2ProfileUrl = `${controllerUrl.replace(/\/$/, '')}${CLAUDE_OAUTH2_PROFILE_PATH}`;
+  }
+  resolved.authorizationServerBase = authorizationServerBase(controllerUrl, resolved.dataplaneBaseUrl);
+}
+
+module.exports = {
+  applyClaudeRuntimeValues
+};

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

@@ -0,0 +1,92 @@
+/**
+ * Customer-facing Claude connector form values: Name, Server URL, OAuth.
+ *
+ * @fileoverview Claude channel form values — describe, don't configure
+ */
+
+'use strict';
+
+const {
+  CLAUDE_OAUTH2_PROFILE_ID,
+  CLAUDE_OAUTH2_PROFILE_PATH,
+  CLAUDE_CONNECTORS_URL
+} = require('./claude-runtime-contract');
+const { getDefaultChannelDescription } = require('./channel-targets');
+
+const CLAUDE_AUTHENTICATION = 'OAuth';
+
+/**
+ * @param {Object|null|undefined} integrationClient
+ * @returns {string}
+ */
+function resolveClaudeClientId(integrationClient) {
+  const fromClient =
+    integrationClient && typeof integrationClient.keycloakClientId === 'string'
+      ? integrationClient.keycloakClientId.trim()
+      : '';
+  return fromClient || CLAUDE_OAUTH2_PROFILE_ID;
+}
+
+/**
+ * @param {Object|null|undefined} asMetadata
+ * @param {string} field
+ * @returns {string|null}
+ */
+function discoveryEndpoint(asMetadata, field) {
+  const value = asMetadata && asMetadata[field];
+  if (typeof value !== 'string' || !value.trim()) {
+    return null;
+  }
+  return value.trim();
+}
+
+/**
+ * @param {Object} params
+ * @returns {Object}
+ */
+function buildClaudeFormValues(params) {
+  const runtimeValues = params.runtimeValues || {};
+  const asMetadata = params.asMetadata || null;
+  const oauth2ProfileUrl =
+    typeof runtimeValues.oauth2ProfileUrl === 'string' ? runtimeValues.oauth2ProfileUrl : '';
+  return {
+    name: runtimeValues.appName || runtimeValues.baseName || '',
+    description:
+      (typeof runtimeValues.appDescription === 'string' && runtimeValues.appDescription.trim()) ||
+      getDefaultChannelDescription(),
+    serverUrl: runtimeValues.mcpUrl || '',
+    authentication: CLAUDE_AUTHENTICATION,
+    clientId: resolveClaudeClientId(params.integrationClient),
+    authorizationUrl: discoveryEndpoint(asMetadata, 'authorization_endpoint'),
+    tokenUrl: discoveryEndpoint(asMetadata, 'token_endpoint'),
+    oauth2ProfileId: CLAUDE_OAUTH2_PROFILE_ID,
+    oauth2ProfilePath: CLAUDE_OAUTH2_PROFILE_PATH,
+    oauth2ProfileUrl,
+    connectorsUrl: CLAUDE_CONNECTORS_URL
+  };
+}
+
+/**
+ * @param {Object} values
+ * @returns {string[]}
+ */
+function formatClaudeFormValueLines(values) {
+  const lines = [];
+  if (values.name) {
+    lines.push(`Name: ${values.name}`);
+  }
+  if (values.serverUrl) {
+    lines.push(`Server URL: ${values.serverUrl}`);
+  }
+  if (values.authentication) {
+    lines.push(`Authentication: ${values.authentication}`);
+  }
+  return lines;
+}
+
+module.exports = {
+  CLAUDE_CONNECTORS_URL,
+  resolveClaudeClientId,
+  buildClaudeFormValues,
+  formatClaudeFormValueLines
+};