@aifabrix/builder 2.49.1 → 2.50.0

package/lib/api/types/enterprise-knowledge.types.js

@@ -0,0 +1,46 @@
+/**
+ * @fileoverview Enterprise Knowledge API type definitions
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+/**
+ * @typedef {Object} GenerateManifestSubscription
+ * @property {string} key
+ * @property {string} [event]
+ * @property {Object<string, *>} [filter]
+ * @property {Object<string, *>} [task]
+ */
+
+/**
+ * @typedef {Object} GenerateManifestRequest
+ * @property {string} domain
+ * @property {string} ownerSystemKey
+ * @property {string} [displayName]
+ * @property {string} [description]
+ * @property {GenerateManifestSubscription[]} [subscriptions]
+ * @property {string[]} [sourceSystemKeys]
+ * @property {string} [version]
+ */
+
+/**
+ * @typedef {Object} GenerateManifestFinding
+ * @property {string} code
+ * @property {string} severity
+ * @property {string} message
+ * @property {Object<string, *>} [context]
+ */
+
+/**
+ * @typedef {Object} GenerateManifestResponse
+ * @property {boolean} previewOnly
+ * @property {string} ownerSystemKey
+ * @property {Object<string, *>} externalSystem
+ * @property {Object<string, *>[]} externalDataSources
+ * @property {string} version
+ * @property {GenerateManifestFinding[]} compilerFindings
+ * @property {GenerateManifestFinding[]} trustFindings
+ * @property {string} message
+ */
+
+module.exports = {};

package/lib/api/types/evidence.types.js

@@ -0,0 +1,67 @@
+/**
+ * @fileoverview JSDoc types for Evidence Fabrix dataplane API.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+/**
+ * @typedef {'active' | 'disabled'} EvidenceStatus
+ */
+
+/**
+ * @typedef {'self' | 'role' | 'roleExceptSelf'} EvidenceApprover
+ */
+
+/**
+ * @typedef {Object} EvidenceApprovalPolicy
+ * @property {boolean} required
+ * @property {EvidenceApprover} approver
+ * @property {string|null} [roleKey]
+ */
+
+/**
+ * @typedef {Object} EvidenceRow
+ * @property {string} id
+ * @property {string} resourceType
+ * @property {string|null} [roleKey]
+ * @property {string} title
+ * @property {string|null} [description]
+ * @property {string} when
+ * @property {string} expectedBehavior
+ * @property {number} order
+ * @property {EvidenceStatus} status
+ * @property {number|null} [generationConfidence]
+ * @property {string|null} [suggestionExplanation]
+ * @property {EvidenceApprovalPolicy} approval
+ * @property {'human' | 'assistant'} createdByType
+ * @property {string} createdById
+ * @property {string} createdAt
+ * @property {string} updatedAt
+ */
+
+/**
+ * @typedef {Object} EvidenceCreatePayload
+ * @property {string} resourceType
+ * @property {string|null} [roleKey]
+ * @property {string} title
+ * @property {string|null} [description]
+ * @property {string} when
+ * @property {string} expectedBehavior
+ * @property {number|null} [order]
+ * @property {EvidenceStatus} [status]
+ * @property {EvidenceApprovalPolicy} [approval]
+ */
+
+/**
+ * @typedef {Partial<EvidenceCreatePayload>} EvidenceUpdatePayload
+ */
+
+/**
+ * @typedef {Object} EvidenceListParams
+ * @property {string} [resourceType]
+ * @property {string} [roleKey]
+ * @property {boolean} [genericOnly]
+ * @property {EvidenceStatus} [status]
+ */
+
+module.exports = {};

package/lib/api/types/resource-types.types.js

@@ -28,6 +28,7 @@
  * @property {ResourceTypeCategory} [category] - Catalog category
  * @property {ResourceTypeRiskLevel} [defaultRiskLevel] - Default risk level
  * @property {ResourceTypeStatus} [status] - Lifecycle status
+ * @property {string} domain - Enterprise domain (static dimension catalog)
  */
 
 /**
@@ -40,6 +41,7 @@
  * @property {ResourceTypeCategory} category - Category
  * @property {ResourceTypeRiskLevel} defaultRiskLevel - Default risk
  * @property {ResourceTypeStatus} status - Status
+ * @property {string} domain - Enterprise domain
  */
 
 module.exports = {};

package/lib/app/controller-application-filter.js

@@ -0,0 +1,36 @@
+/**
+ * Distinguish controller pipeline applications from connected-system (external) registry rows.
+ *
+ * @fileoverview Filter helpers for aifabrix app list vs connected systems list
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+/**
+ * @param {Object} app - Controller application row
+ * @returns {boolean} True when the row represents a connected system, not a runnable app
+ */
+function isControllerExternalApplication(app) {
+  if (!app || typeof app !== 'object') return false;
+  const cfg = app.configuration && typeof app.configuration === 'object' ? app.configuration : {};
+  const appType = app.type ?? cfg.type;
+  return String(appType || '').toLowerCase() === 'external';
+}
+
+/**
+ * @param {Array<Object>} applications - Controller application rows
+ * @returns {{ applications: Array<Object>, excludedCount: number }}
+ */
+function filterControllerApplications(applications) {
+  const list = Array.isArray(applications) ? applications : [];
+  const excludedCount = list.filter(isControllerExternalApplication).length;
+  return {
+    applications: list.filter((app) => !isControllerExternalApplication(app)),
+    excludedCount
+  };
+}
+
+module.exports = {
+  isControllerExternalApplication,
+  filterControllerApplications
+};

package/lib/app/deploy.js

@@ -255,7 +255,7 @@ function displayDeploymentResults(result) {
  * @returns {Promise<Object|null>} Deployment result if external, null otherwise
  */
 async function handleExternalDeployment(appName, options) {
-  const { isExternal } = await detectAppType(appName);
+  const { isExternal } = await detectAppType(appName, options);
   if (isExternal) {
     const externalDeploy = require('../external-system/deploy');
     await externalDeploy.deployExternalSystem(appName, options);

package/lib/app/list-external-systems.js

@@ -0,0 +1,130 @@
+/**
+ * List connected systems published on the dataplane.
+ *
+ * @fileoverview aifabrix list command — dataplane GET /api/v1/external/systems
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const { formatBlockingError } = require('../utils/cli-test-layout-chalk');
+const { getConfig, resolveEnvironment } = require('../core/config');
+const { resolveControllerUrl } = require('../utils/controller-url');
+const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
+const { listExternalSystems } = require('../api/external-systems.api');
+const { formatApiError } = require('../utils/api-error-handler');
+const { getListAuthToken } = require('./list');
+const logger = require('../utils/logger');
+
+/**
+ * Normalize list response shapes from the dataplane API client.
+ * @param {Object} response - API client response
+ * @returns {Array<Object>}
+ */
+function extractExternalSystems(response) {
+  const apiResponse = response?.data;
+  if (Array.isArray(apiResponse)) return apiResponse;
+  if (apiResponse && Array.isArray(apiResponse.items)) return apiResponse.items;
+  if (apiResponse && Array.isArray(apiResponse.data)) return apiResponse.data;
+  if (apiResponse && apiResponse.data && Array.isArray(apiResponse.data.items)) {
+    return apiResponse.data.items;
+  }
+  return [];
+}
+
+/**
+ * @param {Array<Object>} systems
+ * @param {string} environment
+ * @param {string} dataplaneUrl
+ * @param {boolean} json
+ */
+function displayExternalSystems(systems, environment, dataplaneUrl, json) {
+  if (json) {
+    logger.log(JSON.stringify({ environment, dataplaneUrl, systems }, null, 2));
+    return;
+  }
+
+  const environmentName = environment || 'miso';
+  const header = `Connected systems in ${environmentName} (${dataplaneUrl})`;
+  if (systems.length === 0) {
+    logger.log(chalk.bold(`\n🔗 ${header}:\n`));
+    logger.log(chalk.gray('  No connected systems found on the dataplane.\n'));
+    return;
+  }
+
+  logger.log(chalk.bold(`\n🔗 ${header}:\n`));
+  systems.forEach((system) => {
+    const key = system.key || system.systemKey || system.id || '—';
+    const displayName = system.displayName || key;
+    const status = system.status || 'unknown';
+    logger.log(`✔ ${chalk.cyan(key)} - ${displayName} (${status})`);
+  });
+  logger.log(chalk.gray('  To show details: aifabrix show <systemKey> --online\n'));
+}
+
+/**
+ * @param {Object} [options]
+ * @returns {Promise<{ environment: string, authConfig: Object, dataplaneUrl: string }|null>}
+ */
+async function resolveDataplaneListContext(options = {}) {
+  const controllerUrl = options.controller || (await resolveControllerUrl());
+  if (!controllerUrl) {
+    logger.error(formatBlockingError('Controller URL is required. Run "aifabrix login".'));
+    process.exit(1);
+    return null;
+  }
+
+  const environment = options.environment || (await resolveEnvironment());
+  const config = await getConfig();
+  const { token, actualControllerUrl } = await getListAuthToken(controllerUrl, config);
+  if (!token || !actualControllerUrl) {
+    return null;
+  }
+
+  const authConfig = { type: 'bearer', token };
+  try {
+    const dataplaneUrl = await resolveDataplaneUrl(actualControllerUrl, environment, authConfig);
+    return { environment, authConfig, dataplaneUrl };
+  } catch (error) {
+    logger.error(formatBlockingError(`Failed to resolve dataplane URL: ${error.message}`));
+    process.exit(1);
+    return null;
+  }
+}
+
+/**
+ * List connected systems on the dataplane for the current environment.
+ * @async
+ * @param {Object} [options]
+ * @param {string} [options.controller]
+ * @param {string} [options.environment]
+ * @param {boolean} [options.json]
+ */
+async function listExternalSystemsOnDataplane(options = {}) {
+  const ctx = await resolveDataplaneListContext(options);
+  if (!ctx) {
+    return;
+  }
+
+  try {
+    const response = await listExternalSystems(ctx.dataplaneUrl, ctx.authConfig, { pageSize: 100 });
+    if (!response.success) {
+      const formatted = response.formattedError || formatApiError(response, ctx.dataplaneUrl);
+      logger.error(formatted);
+      process.exit(1);
+      return;
+    }
+    const systems = extractExternalSystems(response);
+    displayExternalSystems(systems, ctx.environment, ctx.dataplaneUrl, Boolean(options.json));
+  } catch (error) {
+    logger.error(formatBlockingError(`Failed to list connected systems from dataplane: ${ctx.dataplaneUrl}`));
+    logger.error(chalk.gray(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  listExternalSystemsOnDataplane,
+  extractExternalSystems,
+  displayExternalSystems
+};

package/lib/app/list.js

@@ -16,6 +16,7 @@ const { listEnvironmentApplications } = require('../api/environments.api');
 const { formatApiError } = require('../utils/api-error-handler');
 const { formatAuthenticationError } = require('../utils/error-formatters/http-status-errors');
 const logger = require('../utils/logger');
+const { filterControllerApplications } = require('./controller-application-filter');
 
 /**
  * Extract wrapped array format: { success: true, data: { success: true, data: [...] } }
@@ -153,24 +154,30 @@ function formatUrlAndPort(app) {
  * @param {string} environment - Environment name or key
  * @param {string} controllerUrl - Controller URL
  */
-function displayApplications(applications, environment, controllerUrl) {
+function displayApplications(applications, environment, controllerUrl, excludedCount = 0) {
   const environmentName = environment || 'miso';
   const header = `Applications in ${environmentName} environment (${controllerUrl})`;
 
   if (applications.length === 0) {
     logger.log(chalk.bold(`\n📱 ${header}:\n`));
+    if (excludedCount > 0) {
+      logger.log(chalk.gray(`  No controller applications found (${excludedCount} connected system(s) hidden).`));
+      logger.log(chalk.gray('  List connected systems: aifabrix list\n'));
+      return;
+    }
     logger.log(chalk.gray('  No applications found in this environment.\n'));
     return;
   }
 
   logger.log(chalk.bold(`\n📱 ${header}:\n`));
   applications.forEach((app) => {
-    const isExternal = app.configuration?.type === 'external';
-    const externalIcon = isExternal ? '🔗 ' : '';
     const hasPipeline = app.configuration?.pipeline?.isActive ? '✔' : '✖';
     const urlAndPort = formatUrlAndPort(app);
-    logger.log(`${externalIcon}${hasPipeline} ${chalk.cyan(app.key)} - ${app.displayName} (${app.status || 'unknown'})${urlAndPort}`);
+    logger.log(`${hasPipeline} ${chalk.cyan(app.key)} - ${app.displayName} (${app.status || 'unknown'})${urlAndPort}`);
   });
+  if (excludedCount > 0) {
+    logger.log(chalk.gray(`  (${excludedCount} connected system(s) omitted — use: aifabrix list)`));
+  }
   logger.log(chalk.gray('  To show details for an app: aifabrix app show <app>\n'));
 }
 
@@ -295,6 +302,13 @@ function handleListResponse(response, actualControllerUrl) {
  * @param {Object} [_options] - Command options (reserved)
  * @throws {Error} If listing fails
  */
+async function fetchAndDisplayApplications(actualControllerUrl, environment, authConfig) {
+  const response = await listEnvironmentApplications(actualControllerUrl, environment, authConfig);
+  const applications = handleListResponse(response, actualControllerUrl);
+  const { applications: controllerApps, excludedCount } = filterControllerApplications(applications);
+  displayApplications(controllerApps, environment, actualControllerUrl, excludedCount);
+}
+
 async function listApplications(options = {}) {
   const { resolveControllerUrl } = require('../utils/controller-url');
   const { resolveEnvironment } = require('../core/config');
@@ -318,9 +332,7 @@ async function listApplications(options = {}) {
   // Use centralized API client
   const authConfig = { type: 'bearer', token: token };
   try {
-    const response = await listEnvironmentApplications(actualControllerUrl, environment, authConfig);
-    const applications = handleListResponse(response, actualControllerUrl);
-    displayApplications(applications, environment, actualControllerUrl);
+    await fetchAndDisplayApplications(actualControllerUrl, environment, authConfig);
   } catch (error) {
     logger.error(formatBlockingError(`Failed to list applications from controller: ${actualControllerUrl}`));
     logger.error(chalk.gray(`Error: ${error.message}`));
@@ -328,5 +340,5 @@ async function listApplications(options = {}) {
   }
 }
 
-module.exports = { listApplications };
+module.exports = { listApplications, getListAuthToken };
 

package/lib/app/run.js

@@ -229,7 +229,9 @@ async function resolveRunOptions(appName, appConfig, options, envKey, debug, eff
     effectiveEnvironmentScopedResources: Boolean(effectiveEnvironmentScopedResources)
   };
   const builderPath = pathsUtil.getBuilderPath(appName);
-  const codePath = pathsUtil.resolveBuildContext(builderPath, appConfig.build?.context || '.');
+  const buildContext = appConfig.build?.context || '.';
+  const { resolveSystemAppReloadSourceRoot } = require('../utils/paths-reload-source');
+  const codePath = resolveSystemAppReloadSourceRoot(appName, builderPath, buildContext);
   if (options.reload && envKey === 'dev') {
     const remoteSyncPath = appConfig.build?.remoteSyncPath;
     const reloadSummary = await ensureReloadSync(appName, appConfig.developerId, debug, codePath, remoteSyncPath);

package/lib/app/show-display.js

@@ -14,9 +14,14 @@ const logger = require('../utils/logger');
 
 function logSourceAndHeader(summary) {
   const isOffline = summary.source === 'offline';
-  const sourceLabel = isOffline
-    ? `🔴 Source: offline (${summary.path || '—'})`
-    : `🟢 Source: online (${summary.controllerUrl || '—'})`;
+  let sourceLabel;
+  if (isOffline) {
+    sourceLabel = `🔴 Source: offline (${summary.path || '—'})`;
+  } else if (summary.externalOnly && summary.dataplaneUrl) {
+    sourceLabel = `🟢 Source: online (dataplane ${summary.dataplaneUrl})`;
+  } else {
+    sourceLabel = `🟢 Source: online (${summary.controllerUrl || '—'})`;
+  }
   logger.log(sourceLabel);
   logger.log('');
 }

package/lib/app/show-online.js

@@ -0,0 +1,178 @@
+/**
+ * Online show resolution: controller applications vs dataplane connected systems.
+ *
+ * @fileoverview aifabrix show --online and app show routing
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const logger = require('../utils/logger');
+const { getConfig } = require('../core/config');
+const { resolveControllerUrl } = require('../utils/controller-url');
+const { resolveEnvironment } = require('../core/config');
+const { getApplication } = require('../api/applications.api');
+const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
+const { formatApiError } = require('../utils/api-error-handler');
+const { isControllerExternalApplication } = require('./controller-application-filter');
+const {
+  getShowAuthToken,
+  buildOnlineSummary,
+  fetchExternalSystemFromDataplane,
+  enrichExternalShowSummary,
+  attachRunDefaultsFromUserConfig,
+  attachDeclarativeUrlsToShowApplication,
+  outputOnlineJson,
+  tryGetLocalManifestSourceForJson
+} = require('./show');
+
+async function resolveOnlineAuth(controllerUrl) {
+  const config = await getConfig();
+  const authResult = await getShowAuthToken(controllerUrl, config);
+  return { authConfig: { type: 'bearer', token: authResult.token }, authResult };
+}
+
+function ensureControllerApplicationResponse(response, appKey, authResult, appsOnly) {
+  if (response.success) {
+    const app = response.data?.data || response.data || response;
+    if (appsOnly && isControllerExternalApplication(app)) {
+      throw new Error(
+        `"${appKey}" is a connected system, not a controller application. Use: aifabrix show ${appKey} --online`
+      );
+    }
+    return response.data || response;
+  }
+  if (response.status === 404) {
+    if (appsOnly) {
+      throw new Error(`Application "${appKey}" not found on controller.`);
+    }
+    return null;
+  }
+  const formatted = response.formattedError || formatApiError(response, authResult.actualControllerUrl);
+  logger.error(formatted);
+  throw new Error('Failed to get application from controller.');
+}
+
+function buildOnlineSummaryFromDataplane(appKey, controllerUrl, dataplaneUrl, externalSystem) {
+  const es = externalSystem && !externalSystem.error ? externalSystem : null;
+  const application = {
+    key: appKey,
+    displayName: es?.displayName || appKey,
+    description: es?.application?.description || '—',
+    type: 'external',
+    status: es?.status || es?.dataplaneStatus || '—',
+    version: es?.version || '—',
+    deploymentKey: '—',
+    image: '—',
+    registryMode: '—',
+    port: '—',
+    healthCheck: '—',
+    build: '—',
+    roles: es?.application?.roles,
+    permissions: es?.application?.permissions
+  };
+  return {
+    source: 'online',
+    controllerUrl,
+    dataplaneUrl,
+    appKey,
+    application,
+    roles: es?.application?.roles || [],
+    permissions: es?.application?.permissions || [],
+    authentication: null,
+    portalInputConfigurations: [],
+    databases: [],
+    isExternal: true,
+    externalOnly: true,
+    externalSystem: es || externalSystem
+  };
+}
+
+async function finishOnlineShow(summary, appKey, json, permissionsOnly, verifyCert, authBundle) {
+  await enrichExternalShowSummary(summary, appKey, verifyCert, authBundle);
+  attachRunDefaultsFromUserConfig(summary, appKey, await getConfig());
+  await attachDeclarativeUrlsToShowApplication(summary, appKey);
+  if (json) {
+    const manifestSource = await tryGetLocalManifestSourceForJson(appKey);
+    outputOnlineJson(summary, permissionsOnly, manifestSource);
+    return;
+  }
+  const { display: displayShow } = require('./show-display');
+  displayShow(summary, { permissionsOnly: !!permissionsOnly });
+}
+
+async function runOnlineFromDataplane(appKey, json, permissionsOnly, verifyCert, authConfig, authResult) {
+  const environment = await resolveEnvironment();
+  const dataplaneUrl = await resolveDataplaneUrl(authResult.actualControllerUrl, environment, authConfig);
+  const externalSystem = await fetchExternalSystemFromDataplane(dataplaneUrl, appKey, authConfig);
+  if (!externalSystem || externalSystem.error) {
+    throw new Error(
+      `"${appKey}" was not found as a controller application or connected system on the dataplane.`
+    );
+  }
+  const summary = buildOnlineSummaryFromDataplane(
+    appKey,
+    authResult.actualControllerUrl,
+    dataplaneUrl,
+    externalSystem
+  );
+  await finishOnlineShow(summary, appKey, json, permissionsOnly, verifyCert, {
+    token: authConfig.token,
+    controllerUrl: authResult.actualControllerUrl
+  });
+}
+
+/**
+ * @param {string} appKey
+ * @param {Object} appData
+ * @param {Object} authConfig
+ * @param {Object} authResult
+ * @returns {Promise<Object|null>}
+ */
+async function loadExternalSystemForOnlineShow(appKey, appData, authConfig, authResult) {
+  const cfg = appData.configuration && typeof appData.configuration === 'object' ? appData.configuration : {};
+  const isExternalApp = appData.type === 'external' || cfg.type === 'external';
+  if (!isExternalApp) {
+    return null;
+  }
+  const environment = await resolveEnvironment();
+  const dataplaneUrl = await resolveDataplaneUrl(authResult.actualControllerUrl, environment, authConfig);
+  return fetchExternalSystemFromDataplane(dataplaneUrl, appKey, authConfig);
+}
+
+/**
+ * @param {string} appKey
+ * @param {{ json?: boolean, permissionsOnly?: boolean, verifyCert?: boolean, appsOnly?: boolean }} options
+ */
+async function runOnlineShow(appKey, options = {}) {
+  const controllerUrl = await resolveControllerUrl();
+  if (!controllerUrl) {
+    throw new Error('Controller URL is required for --online. Run aifabrix login to set the controller URL in config.yaml.');
+  }
+
+  const json = Boolean(options.json);
+  const permissionsOnly = Boolean(options.permissionsOnly);
+  const verifyCert = Boolean(options.verifyCert);
+  const appsOnly = Boolean(options.appsOnly);
+
+  const { authConfig, authResult } = await resolveOnlineAuth(controllerUrl);
+  const response = await getApplication(controllerUrl, appKey, authConfig);
+  const apiApp = ensureControllerApplicationResponse(response, appKey, authResult, appsOnly);
+  if (!apiApp) {
+    await runOnlineFromDataplane(appKey, json, permissionsOnly, verifyCert, authConfig, authResult);
+    return;
+  }
+
+  const appData = apiApp.data || apiApp;
+  const externalSystem = await loadExternalSystemForOnlineShow(appKey, appData, authConfig, authResult);
+  const summary = buildOnlineSummary(apiApp, authResult.actualControllerUrl, externalSystem);
+  await finishOnlineShow(summary, appKey, json, permissionsOnly, verifyCert, {
+    token: authConfig.token,
+    controllerUrl: authResult.actualControllerUrl
+  });
+}
+
+module.exports = {
+  runOnlineShow,
+  buildOnlineSummaryFromDataplane,
+  ensureControllerApplicationResponse
+};