@aifabrix/builder 2.53.1 → 2.55.0

package/lib/programmatic/run-auth-permissions.js

@@ -0,0 +1,54 @@
+/**
+ * Thin Builder forward of Miso GET /api/v1/auth/permissions.
+ *
+ * @fileoverview Portal uses published builder-api; no second permission model
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { getAuthPermissions } = require('../api/auth.api');
+const { permissionSlugsFromResponse } = require('../channels/channel-oauth-preflight');
+const { httpError } = require('./channel-install-session');
+
+/**
+ * @param {unknown} errOrResponse
+ * @returns {Error}
+ */
+function mapPermissionsError(errOrResponse) {
+  const status = Number(
+    errOrResponse && (errOrResponse.statusCode || errOrResponse.status)
+  ) || 502;
+  const message =
+    (errOrResponse && (errOrResponse.formattedError || errOrResponse.message)) ||
+    'Unable to read authorization permissions.';
+  return httpError(String(message), status >= 400 && status < 600 ? status : 502);
+}
+
+/**
+ * @param {import('./workspace-context').WorkspaceContext} ctx
+ * @param {Object} [deps]
+ * @returns {Promise<{ permissions: string[] }>}
+ */
+async function getBuilderAuthPermissions(ctx, deps = {}) {
+  const getPerms = deps.getAuthPermissions || getAuthPermissions;
+  let response;
+  try {
+    response = await getPerms(
+      ctx.controllerUrl,
+      { type: 'bearer', token: ctx.bearerToken, preserveBearer: true },
+      ctx.environment
+    );
+  } catch (err) {
+    throw mapPermissionsError(err);
+  }
+  if (response && response.success === false) {
+    throw mapPermissionsError(response);
+  }
+  return { permissions: permissionSlugsFromResponse(response) };
+}
+
+module.exports = {
+  getBuilderAuthPermissions
+};

package/lib/programmatic/run-channel-catalog.js

@@ -0,0 +1,238 @@
+/**
+ * Catalog, definition, and installation projection handlers.
+ *
+ * @fileoverview GET /channels[+/:definitionKey][+ /installations/:systemKey]
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const registry = require('../channels/channel-definition-registry');
+const { listLiveChannelTargetKeys, getChannelTarget } = require('../channels/channel-targets');
+const { profilesForCatalogRow } = require('../channels/channel-install-profiles');
+const { toSafeConfiguration, toPortalFields } = require('../channels/channel-configuration-map');
+const { catalogIconHref } = require('../channels/channel-catalog-icon');
+const {
+  formatChannelCliInstructions,
+  isCliProvisioningMode
+} = require('../channels/channel-cli-instructions');
+const {
+  installationsForDefinition,
+  summarizeInstallations
+} = require('../channels/channel-install-inventory');
+const { listConnectedSystemsForInventory } = require('../channels/channel-inventory-fetch');
+const { cardinalityProjection } = require('../channels/channel-cardinality');
+const {
+  applyChannelStatusProjection,
+  normalizeChannelStatus
+} = require('../channels/channel-definition-status');
+const { httpError } = require('./channel-install-session');
+const { getExternalSystem } = require('../api/external-systems.api');
+const { unwrapApiData } = require('../utils/external-system-readiness-core');
+const { isNotFoundError } = require('../channels/channel-instance-collision');
+
+/**
+ * @param {Object} target
+ * @param {Object[]} [installations]
+ * @returns {Object}
+ */
+function toChannelCatalogRow(target, installations = []) {
+  const summary = summarizeInstallations(installations);
+  const definition = registry.getChannelDefinition(target.key);
+  const row = {
+    key: target.key,
+    displayLabel: target.displayLabel,
+    description: target.description,
+    experimental: target.experimental === true,
+    provisioning: target.provisioning || { mode: 'guided' },
+    runtimeTarget: target.runtimeTarget,
+    installationSummary: summary,
+    installations,
+    ...definitionListFields(target.key)
+  };
+  const profiles = profilesForCatalogRow(target.key);
+  if (profiles.length > 0) {
+    row.profiles = profiles;
+  }
+  return {
+    ...row,
+    ...applyChannelStatusProjection(
+      normalizeChannelStatus(definition),
+      cardinalityProjection(definition, installations)
+    )
+  };
+}
+
+/**
+ * Safe definition fields for the published catalog list (portal form + CLI copy).
+ * @param {string} definitionKey
+ * @returns {Object}
+ */
+function definitionListFields(definitionKey) {
+  const definition = registry.getChannelDefinition(definitionKey);
+  if (!definition) {
+    return {};
+  }
+  const fields = {
+    configuration: toSafeConfiguration(definition),
+    portalFields: toPortalFields(definition)
+  };
+  const iconHref = catalogIconHref(definitionKey);
+  if (iconHref) {
+    fields.iconHref = iconHref;
+  }
+  if (isCliProvisioningMode(definition)) {
+    fields.cliInstructions = formatChannelCliInstructions(definition);
+  }
+  return fields;
+}
+
+/**
+ * @param {Object} [query]
+ * @param {Object|null} [ctx]
+ * @param {Object} [deps]
+ * @returns {Promise<{ channels: Object[] }>}
+ */
+async function listChannelTargets(query = {}, ctx = null, deps = {}) {
+  const allowExperimental = query.allowExperimental === 'true' || query.allowExperimental === true;
+  const systems = ctx ? await listConnectedSystemsForInventory(ctx, deps) : [];
+  const channels = listLiveChannelTargetKeys({ allowExperimental }).map((key) => {
+    const target = getChannelTarget(key);
+    const installations = installationsForDefinition(systems, key);
+    return toChannelCatalogRow(target, installations);
+  });
+  return { channels };
+}
+
+/**
+ * @param {string} definitionKey
+ * @returns {Object}
+ */
+function requireChannelDefinition(definitionKey) {
+  const definition = registry.getChannelDefinition(definitionKey);
+  if (!definition || normalizeChannelStatus(definition) === 'hide') {
+    throw httpError(`Unknown channel definition "${definitionKey}".`, 404);
+  }
+  return definition;
+}
+
+/**
+ * @param {Object} definition
+ * @returns {Object}
+ */
+function toSafeDefinition(definition) {
+  const channel = definition.channel || {};
+  const safe = {
+    key: definition.key,
+    displayName: definition.displayName,
+    description: definition.description,
+    type: definition.type,
+    systemKind: definition.systemKind,
+    configuration: toSafeConfiguration(definition),
+    portalFields: toPortalFields(definition),
+    channel: {
+      definitionKey: channel.definitionKey || definition.key,
+      provisioning: channel.provisioning,
+      runtimeTarget: channel.runtimeTarget,
+      experimental: channel.experimental === true,
+      status: normalizeChannelStatus(definition),
+      profiles: Array.isArray(channel.profiles) ? channel.profiles : []
+    }
+  };
+  if (typeof channel.maxInstances === 'number') {
+    safe.channel.maxInstances = channel.maxInstances;
+  }
+  const iconHref = catalogIconHref(definition.key);
+  if (iconHref) {
+    safe.iconHref = iconHref;
+  }
+  if (isCliProvisioningMode(definition)) {
+    safe.cliInstructions = formatChannelCliInstructions(definition);
+  }
+  return safe;
+}
+
+/**
+ * @param {Object} ctx
+ * @param {string} definitionKey
+ * @param {Object} [deps]
+ * @returns {Promise<Object>}
+ */
+async function getChannelDefinitionDetail(ctx, definitionKey, deps = {}) {
+  const definition = requireChannelDefinition(definitionKey);
+  const systems = await listConnectedSystemsForInventory(ctx, deps);
+  const installations = installationsForDefinition(systems, definition.key);
+  return {
+    ...toSafeDefinition(definition),
+    ...applyChannelStatusProjection(
+      normalizeChannelStatus(definition),
+      cardinalityProjection(definition, installations)
+    ),
+    installations
+  };
+}
+
+/**
+ * @param {Object} ctx
+ * @param {string} definitionKey
+ * @param {string} systemKey
+ * @param {Object} [deps]
+ * @returns {Promise<Object>}
+ */
+async function installationFromDirectLookup(ctx, definitionKey, systemKey, deps) {
+  const getSystem = deps.getExternalSystem || getExternalSystem;
+  try {
+    const res = await getSystem(ctx.dataplaneUrl, systemKey, {
+      type: 'bearer',
+      token: ctx.bearerToken,
+      preserveBearer: true
+    });
+    const system = unwrapApiData(res);
+    return installationsForDefinition(system ? [system] : [], definitionKey)[0] || null;
+  } catch (err) {
+    if (isNotFoundError(err)) {
+      return null;
+    }
+    throw err;
+  }
+}
+
+/**
+ * @param {Object} ctx
+ * @param {string} definitionKey
+ * @param {string} systemKey
+ * @param {Object} [deps]
+ * @returns {Promise<Object>}
+ */
+async function getChannelInstallation(ctx, definitionKey, systemKey, deps = {}) {
+  requireChannelDefinition(definitionKey);
+  const systems = await listConnectedSystemsForInventory(ctx, deps);
+  const fromList = installationsForDefinition(systems, definitionKey).find(
+    (row) => row.key === systemKey
+  );
+  const found = fromList || (await installationFromDirectLookup(ctx, definitionKey, systemKey, deps));
+  if (!found) {
+    throw httpError(
+      `Channel installation "${systemKey}" was not found for "${definitionKey}".`,
+      404
+    );
+  }
+  return {
+    definition: {
+      key: definitionKey,
+      displayName: getChannelTarget(definitionKey).displayLabel,
+      provisioning: getChannelTarget(definitionKey).provisioning
+    },
+    installation: found
+  };
+}
+
+module.exports = {
+  listChannelTargets,
+  getChannelDefinitionDetail,
+  getChannelInstallation,
+  toChannelCatalogRow,
+  toSafeDefinition,
+  requireChannelDefinition
+};

package/lib/programmatic/run-channel-install-artifacts.js

@@ -0,0 +1,137 @@
+/**
+ * Channel install artifact bytes and vendor callback (no secrets in responses).
+ *
+ * @fileoverview Linked from help markdown; ZIP as application/zip
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('../internal/fs-real-sync');
+const path = require('path');
+const { getChannelPackageZip } = require('./run-channel-package');
+const { createHttpRawResult } = require('./http-raw-response');
+const {
+  httpError,
+  readChannelInstallSession,
+  requireChannelInstallSession
+} = require('./channel-install-session');
+const { getArtifactOutputPath } = require('../channels/channel-artifact-generator');
+const { toChannelInstallHttpPayload } = require('../channels/channel-install-http-payload');
+const { attachInstallIdentity } = require('./channel-install-help-resolve');
+
+/**
+ * Credential callback hook — never echo tokens. Tests may inject a mock.
+ * @param {import('./workspace-context').WorkspaceContext} _ctx
+ * @param {string} _provider
+ * @param {Object} _payload
+ * @returns {Promise<{ stored: boolean }>}
+ */
+async function storeChannelCallbackCredential(_ctx, _provider, _payload) {
+  return { stored: false };
+}
+
+/**
+ * @param {import('./workspace-context').WorkspaceContext} ctx
+ * @returns {Object}
+ */
+function listChannelArtifacts(ctx) {
+  const session = readChannelInstallSession(ctx);
+  const artifacts =
+    session && session.envelope && Array.isArray(session.envelope.artifacts)
+      ? session.envelope.artifacts
+      : [];
+  return { artifacts };
+}
+
+/**
+ * @param {import('./workspace-context').WorkspaceContext} ctx
+ * @param {string} artifactId
+ * @returns {{ absPath: string, contentType: string, fileName: string }}
+ */
+function resolveArtifactFile(ctx, artifactId) {
+  const id = String(artifactId || '').trim();
+  const root = ctx.getUserRoot();
+  const target = ctx.systemKey;
+  if (id === 'appPackage') {
+    const zip = getChannelPackageZip(ctx);
+    const zipPath = path.join(root, 'dist', 'channels', target, 'build', zip.fileName);
+    if (fs.existsSync(zipPath)) {
+      return { absPath: zipPath, contentType: 'application/zip', fileName: zip.fileName };
+    }
+  }
+  if (id === 'manifest') {
+    const absPath = getArtifactOutputPath(root, target);
+    if (fs.existsSync(absPath)) {
+      return { absPath, contentType: 'application/json', fileName: path.basename(absPath) };
+    }
+  }
+  if (id === 'installMd') {
+    const absPath = path.join(path.dirname(getArtifactOutputPath(root, target)), 'INSTALL.md');
+    if (fs.existsSync(absPath)) {
+      return { absPath, contentType: 'text/markdown; charset=utf-8', fileName: 'INSTALL.md' };
+    }
+  }
+  throw httpError(`Artifact not found: ${id}`, 404);
+}
+
+/**
+ * @param {import('./workspace-context').WorkspaceContext} ctx
+ * @param {string} artifactId
+ * @returns {Object}
+ */
+function getChannelArtifact(ctx, artifactId) {
+  if (artifactId === 'appPackage') {
+    return getChannelPackageZip(ctx);
+  }
+  const file = resolveArtifactFile(ctx, artifactId);
+  return createHttpRawResult({
+    contentType: file.contentType,
+    body: fs.readFileSync(file.absPath),
+    fileName: file.fileName
+  });
+}
+
+/**
+ * @param {Object} query
+ * @param {Object} body
+ * @returns {Object}
+ */
+function mergeCallbackPayload(query, body) {
+  return { ...(query && typeof query === 'object' ? query : {}), ...(body && typeof body === 'object' ? body : {}) };
+}
+
+/**
+ * @param {import('./workspace-context').WorkspaceContext} ctx
+ * @param {string} provider
+ * @param {Object} query
+ * @param {Object} body
+ * @param {Object} [deps]
+ * @returns {Promise<Object>}
+ */
+async function handleChannelCallback(ctx, provider, query, body, deps = {}) {
+  const session = requireChannelInstallSession(ctx);
+  const store = deps.storeCallback || storeChannelCallbackCredential;
+  await store(ctx, String(provider || ''), mergeCallbackPayload(query, body));
+  if (session.envelope && typeof session.envelope === 'object') {
+    const payload = toChannelInstallHttpPayload(session.envelope);
+    const definitionKey = session.definitionKey || session.channelTarget;
+    const installationKey = session.installationKey;
+    if (!definitionKey || !installationKey) {
+      return payload;
+    }
+    return attachInstallIdentity(payload, definitionKey, installationKey);
+  }
+  return {
+    helpMarkdown: session.helpMarkdown,
+    helpMarkdownContentType: 'text/markdown'
+  };
+}
+
+module.exports = {
+  listChannelArtifacts,
+  getChannelArtifact,
+  handleChannelCallback,
+  storeChannelCallbackCredential
+};