@aifabrix/builder 2.51.1 → 2.52.1

package/lib/datasource/capability/copy-operations.js

@@ -7,7 +7,11 @@
  */
 
 const { rewriteCapabilityReferences } = require('./reference-rewrite');
-const { capabilityKeyFromEntry } = require('./capability-manifest');
+const {
+  capabilityKeyFromEntry,
+  capabilitiesIncludes,
+  buildCapabilityObject
+} = require('./capability-manifest');
 const { jsonPointerPath } = require('./json-pointer');
 const { buildBasicExposureProfileArray } = require('./basic-exposure');
 const {
@@ -256,14 +260,20 @@ function appendCapabilityList(doc, resolvedAs, patchOperations, updatedSections)
   if (!Array.isArray(doc.capabilities)) {
     doc.capabilities = [];
   }
-  if (doc.capabilities.includes(resolvedAs)) {
+  if (capabilitiesIncludes(doc.capabilities, resolvedAs)) {
     return;
   }
-  doc.capabilities.push(resolvedAs);
+  const usesObjects = doc.capabilities.some(
+    (entry) => entry && typeof entry === 'object' && !Array.isArray(entry)
+  );
+  const value = usesObjects
+    ? buildCapabilityObject(resolvedAs, doc.displayName || doc.key || 'records')
+    : resolvedAs;
+  doc.capabilities.push(value);
   patchOperations.push({
     op: 'add',
     path: '/capabilities/-',
-    value: resolvedAs
+    value
   });
   updatedSections.push(`capabilities[]: ${resolvedAs}`);
 }

package/lib/datasource/datasource-identifier.js

@@ -7,7 +7,7 @@
 'use strict';
 
 const path = require('path');
-const { getIntegrationPath } = require('../utils/paths');
+const { resolveExternalSystemPath } = require('../utils/app-path-resolve');
 const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
 const { loadConfigFile } = require('../utils/config-format');
 
@@ -65,12 +65,13 @@ function pickIntegrationAppForDatasourceIdentifier(identifier, appNames) {
 }
 
 /**
- * List manifest datasource files for an integration app.
+ * List manifest datasource files for an external authoring app
+ * (integration/, role-assistant/, or enterprise-knowledge/).
  * @param {string} appKey
  * @returns {{ appPath: string, schemaBasePath: string, datasourceFiles: string[] }|null}
  */
 function listDatasourceFilesForApp(appKey) {
-  const appPath = getIntegrationPath(appKey);
+  const appPath = resolveExternalSystemPath(appKey);
   let config;
   try {
     const configPath = resolveApplicationConfigPath(appPath);

package/lib/datasource/integration-context.js

@@ -6,7 +6,7 @@
 
 const path = require('path');
 const fs = require('fs').promises;
-const { getIntegrationPath } = require('../utils/paths');
+const { resolveExternalSystemPath } = require('../utils/app-path-resolve');
 const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
 const { loadConfigFile } = require('../utils/config-format');
 const {
@@ -15,11 +15,11 @@ const {
 } = require('./datasource-identifier');
 
 /**
- * @param {string} appKey - Integration app key
+ * @param {string} appKey - Integration / role-assistant / EK app key
  * @returns {Promise<string>} systemKey
  */
 async function getSystemKeyFromAppKey(appKey) {
-  const appPath = getIntegrationPath(appKey);
+  const appPath = resolveExternalSystemPath(appKey);
   const configPath = resolveApplicationConfigPath(appPath);
   const config = loadConfigFile(configPath);
   if (!config.externalIntegration || !config.externalIntegration.systems || config.externalIntegration.systems.length === 0) {

package/lib/datasource/resolve-app.js

@@ -2,15 +2,20 @@
  * Resolve app key for datasource commands from explicit --app, cwd, scan, or key parse.
  * @fileoverview App resolution for datasource test-e2e, test-integration, log-e2e, log-integration
  * @author AI Fabrix Team
- * @version 2.0.0
+ * @version 2.1.0
  */
 
+'use strict';
+
 const fs = require('fs');
 const {
-  getIntegrationPath,
   listIntegrationAppNames,
+  listEnterpriseKnowledgeAnchors,
+  getRoleAssistantRoot,
+  getCwdRoleAssistantRoot,
   resolveIntegrationAppKeyFromCwd
 } = require('../utils/paths');
+const { resolveExternalSystemPath } = require('../utils/app-path-resolve');
 const {
   appHasDatasourceIdentifier,
   pickIntegrationAppForDatasourceIdentifier
@@ -21,6 +26,80 @@ function appHasDatasourceKey(appKey, datasourceKey) {
   return appHasDatasourceIdentifier(appKey, datasourceKey);
 }
 
+/**
+ * @param {string} appKey
+ * @returns {boolean}
+ */
+function externalAppPathExists(appKey) {
+  try {
+    const appPath = resolveExternalSystemPath(appKey);
+    return Boolean(appPath && fs.existsSync(appPath));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {string} root
+ * @param {Set<string>} diskNames
+ */
+function addRoleAssistantAppDirs(root, diskNames) {
+  if (!root || !fs.existsSync(root)) {
+    return;
+  }
+  let entries;
+  try {
+    entries = fs.readdirSync(root);
+  } catch {
+    return;
+  }
+  const pathJoin = require('path').join;
+  for (const name of entries) {
+    if (!name || name.startsWith('.')) {
+      continue;
+    }
+    try {
+      if (fs.statSync(pathJoin(root, name)).isDirectory()) {
+        diskNames.add(name);
+      }
+    } catch {
+      // skip
+    }
+  }
+}
+
+/**
+ * List app folders under role-assistant/ (cwd + materialization).
+ * @returns {string[]}
+ */
+function listRoleAssistantAppNames() {
+  const diskNames = new Set();
+  const roots = new Set();
+  const cwdRoot = getCwdRoleAssistantRoot();
+  if (cwdRoot) {
+    roots.add(cwdRoot);
+  }
+  roots.add(getRoleAssistantRoot());
+  for (const root of roots) {
+    addRoleAssistantAppDirs(root, diskNames);
+  }
+  return [...diskNames].sort();
+}
+
+/**
+ * External authoring apps: integration + role-assistant + enterprise-knowledge.
+ * @returns {string[]}
+ */
+function listExternalAuthoringAppNames() {
+  return [
+    ...new Set([
+      ...listIntegrationAppNames(),
+      ...listRoleAssistantAppNames(),
+      ...listEnterpriseKnowledgeAnchors()
+    ])
+  ].sort();
+}
+
 /**
  * @param {string} key
  * @param {string} [explicitApp]
@@ -31,7 +110,7 @@ function resolveFromExplicitApp(key, explicitApp) {
     return null;
   }
   const appKey = explicitApp.trim();
-  if (fs.existsSync(getIntegrationPath(appKey))) {
+  if (externalAppPathExists(appKey)) {
     return { appKey };
   }
   return null;
@@ -71,15 +150,16 @@ function resolveFromPrefixOrSegments(key, appNames) {
     return null;
   }
   const candidate = segments.slice(0, -1).join('-');
-  const candidatePath = getIntegrationPath(candidate);
-  if (fs.existsSync(candidatePath) && appHasDatasourceIdentifier(candidate, key)) {
+  if (externalAppPathExists(candidate) && appHasDatasourceIdentifier(candidate, key)) {
     return { appKey: candidate };
   }
   return null;
 }
 
 const RESOLVE_APP_HINT =
-  'Could not determine app context. Use --app <app>, a datasource key, a datasource JSON filename (e.g. myapp-datasource-contacts), or run from integration/<systemKey>/ directory.';
+  'Could not determine app context. Use --app <app>, a datasource key, a datasource JSON filename ' +
+  '(e.g. myapp-datasource-contacts), or run from integration/<systemKey>/, ' +
+  'role-assistant/<systemKey>/, or enterprise-knowledge/<systemKey>/.';
 
 /**
  * Resolve app key for a datasource: explicit --app, cwd, scan by key, or parse key convention.
@@ -108,7 +188,7 @@ async function resolveAppKeyForDatasource(datasourceKey, explicitApp) {
     return { appKey: fromCwd };
   }
 
-  const appNames = listIntegrationAppNames();
+  const appNames = listExternalAuthoringAppNames();
   const scanned = resolveFromAppScan(key, appNames);
   if (scanned) {
     return scanned;
@@ -124,5 +204,7 @@ async function resolveAppKeyForDatasource(datasourceKey, explicitApp) {
 
 module.exports = {
   resolveAppKeyForDatasource,
-  appHasDatasourceKey
+  appHasDatasourceKey,
+  listExternalAuthoringAppNames,
+  listRoleAssistantAppNames
 };

package/lib/datasource/test-e2e.js

@@ -9,7 +9,6 @@ const path = require('path');
 const fs = require('fs').promises;
 const chalk = require('chalk');
 const logger = require('../utils/logger');
-const { getIntegrationPath } = require('../utils/paths');
 const { resolveAppKeyForDatasource } = require('./resolve-app');
 const { formatProgress, formatSuccessLine, infoLine } = require('../utils/cli-test-layout-chalk');
 const { runUnifiedDatasourceValidation } = require('./unified-validation-run');
@@ -94,7 +93,8 @@ async function resolvePrimaryKeyValue(value) {
 }
 
 function e2eIntegrationLogDir(appKey) {
-  return path.dirname(getIntegrationPath(appKey));
+  const { resolveExternalSystemPath } = require('../utils/app-path-resolve');
+  return path.dirname(resolveExternalSystemPath(appKey));
 }
 
 /**

package/lib/datasource/unified-validation-run-body.js

@@ -12,6 +12,16 @@ const {
 const testHelpers = require('../utils/external-system-test-helpers');
 const { withStageOnValidationRunBody } = require('../utils/validation-run-stage');
 
+/**
+ * @param {Object} datasource
+ * @returns {boolean}
+ */
+function isVoidCipInput(datasource) {
+  const execution = datasource && typeof datasource === 'object' ? datasource.execution : null;
+  const cip = execution && typeof execution === 'object' ? execution.cip : null;
+  return String((cip && cip.inputType) || '').trim().toLowerCase() === 'void';
+}
+
 /**
  * @param {Object} params
  * @param {string} params.systemKey
@@ -31,7 +41,11 @@ async function buildUnifiedValidationBody(params) {
     const customPayload = await testHelpers.loadCustomPayload(payloadPath);
     payloadTemplate = testHelpers.determinePayloadTemplate(datasource, datasourceKey, customPayload);
     if (runType === 'integration' && !payloadTemplate) {
-      throw new Error(`No test payload found for datasource '${datasourceKey}'`);
+      if (isVoidCipInput(datasource)) {
+        payloadTemplate = {};
+      } else {
+        throw new Error(`No test payload found for datasource '${datasourceKey}'`);
+      }
     }
   }
 

package/lib/datasource/unified-validation-run-resolve.js

@@ -4,7 +4,7 @@
  * @version 2.0.0
  */
 
-const { getIntegrationPath } = require('../utils/paths');
+const { resolveExternalSystemPath } = require('../utils/app-path-resolve');
 const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
 const { loadConfigFile } = require('../utils/config-format');
 const {
@@ -48,7 +48,7 @@ function findDatasourceFileByIdentifier(appPath, schemaBasePath, datasourceFiles
  * @returns {{ datasource: Object, datasourcePath: string, datasourceKey: string }}
  */
 function loadDatasourceForApp(appKey, datasourceKey, findDatasourceFileByKey) {
-  const appPath = getIntegrationPath(appKey);
+  const appPath = resolveExternalSystemPath(appKey);
   const config = loadConfigFile(resolveApplicationConfigPath(appPath));
   const schemaBasePath = config.externalIntegration?.schemaBasePath || './';
   const datasourceFiles = config.externalIntegration?.dataSources || [];

package/lib/external-system/deploy-helpers.js

@@ -142,7 +142,7 @@ function extractSystemKey(systemFilePath) {
  * @param {Object} manifest - Controller manifest
  * @returns {Promise<Object|null>} Upload result, or null when not a digital worker
  */
-async function uploadDigitalWorkerIfNeeded(appName, options, compact, manifest) {
+async function uploadDigitalWorkerIfNeeded(appName, options, _compact, manifest) {
   const systemKind =
     manifest && manifest.system && typeof manifest.system.systemKind === 'string'
       ? manifest.system.systemKind.trim()
@@ -150,9 +150,9 @@ async function uploadDigitalWorkerIfNeeded(appName, options, compact, manifest)
   if (systemKind !== 'digitalWorker') {
     return null;
   }
-  if (!compact) {
-    const { formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
-    const logger = require('../utils/logger');
+  const { formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
+  const logger = require('../utils/logger');
+  if (options.json !== true) {
     logger.log(
       formatSuccessParagraph(
         'Role Assistant deployment uses upload pipeline (controller deploy is skipped).'
@@ -162,7 +162,11 @@ async function uploadDigitalWorkerIfNeeded(appName, options, compact, manifest)
   const { uploadExternalSystem } = require('../commands/upload');
   return uploadExternalSystem(appName, {
     ...options,
-    uploadStatus: 'published'
+    uploadStatus: 'published',
+    // Match standalone `af upload` progress for the final publish.
+    silentResolve: false,
+    suppressPipelineSpinner: false,
+    syncMode: false
   });
 }
 

package/lib/external-system/deploy.js

@@ -432,7 +432,8 @@ async function runExternalSystemDeployFlow(appName, options) {
   await validateExternalSystemForDeploy(appName, options, compact);
   const gateOutcomes = await runDeployGateOrchestrator(appName, {
     ...options,
-    quietDeployUi: compact
+    // Compact deploy still shows step progress; only JSON mode stays fully quiet.
+    quietDeployUi: options.json === true
   });
   await syncDeployJsonFromSources(appName);
   const manifest = await generateControllerManifest(appName, options);

package/lib/external-system/test-system-level.js

@@ -12,7 +12,7 @@ const path = require('path');
 const chalk = require('chalk');
 const logger = require('../utils/logger');
 const { writeTestLog } = require('../utils/test-log-writer');
-const { getIntegrationPath } = require('../utils/paths');
+const { resolveExternalSystemPath } = require('../utils/app-path-resolve');
 const { runUnifiedDatasourceValidation } = require('../datasource/unified-validation-run');
 
 async function runOneDatasourceKey(appName, datasourceKey, opts) {
@@ -61,16 +61,34 @@ async function runOneDatasourceKey(appName, datasourceKey, opts) {
       };
     }
     const env = uni.envelope;
-    const ok = env && typeof env.status === 'string' ? env.status !== 'fail' : false;
+    const ok = isDatasourceRunSuccessful(env);
     return { key: datasourceKey, success: ok, skipped: false, datasourceTestRun: env };
   } catch (err) {
     return { key: datasourceKey, success: false, skipped: false, error: err.message };
   }
 }
 
+/**
+ * Prefer explicit envelope status; soft-pass when validation+certificate succeeded
+ * (documentStorage packs may report overall fail only for missing live evidence).
+ * @param {Object|null|undefined} env
+ * @returns {boolean}
+ */
+function isDatasourceRunSuccessful(env) {
+  if (!env || typeof env.status !== 'string') {
+    return false;
+  }
+  if (env.status !== 'fail') {
+    return true;
+  }
+  const validationOk = env.validation && env.validation.status === 'ok';
+  const certPassed = env.certificate && env.certificate.status === 'passed';
+  return Boolean(validationOk && certPassed);
+}
+
 async function maybeWriteSystemRunLog(appName, systemKey, datasourceKeys, runType, debug, payload) {
   if (!debug) return;
-  const appPath = getIntegrationPath(appName);
+  const appPath = resolveExternalSystemPath(appName);
   const integrationDir = path.dirname(appPath);
   const logPath = await writeTestLog(
     appName,

package/lib/external-system/test.js

@@ -533,8 +533,8 @@ async function testExternalSystemIntegration(appName, options = {}) {
         if (options.debug) {
           try {
             const { writeTestLog } = require('../utils/test-log-writer');
-            const { getIntegrationPath } = require('../utils/paths');
-            const appPath = getIntegrationPath(appName);
+            const { resolveExternalSystemPath } = require('../utils/app-path-resolve');
+            const appPath = resolveExternalSystemPath(appName);
             await writeTestLog(appName, { request: { systemKey }, error: err.message }, 'test-integration', path.dirname(appPath));
           } catch (_) { /* ignore */ }
         }
@@ -561,8 +561,8 @@ async function testExternalSystemIntegration(appName, options = {}) {
       if (options.debug && results.datasourceResults.length > 0) {
         try {
           const { writeTestLog } = require('../utils/test-log-writer');
-          const { getIntegrationPath } = require('../utils/paths');
-          const appPath = getIntegrationPath(appName);
+          const { resolveExternalSystemPath } = require('../utils/app-path-resolve');
+          const appPath = resolveExternalSystemPath(appName);
           await writeTestLog(appName, {
             request: { systemKey, datasource: options.datasource, includeDebug: true },
             response: results

package/lib/generator/builders.js

@@ -27,24 +27,18 @@ function sanitizeAuthType(authType) {
 }
 
 /**
- * Filters configuration based on registry mode
- * When registryMode is "external", only DOCKER_REGISTRY_SERVER_* variables are allowed
+ * Historically (incorrectly) stripped all non-DOCKER_REGISTRY_* vars when
+ * registryMode was "external", which wiped platform app env/portal config on
+ * `aifabrix json`. External only means image pull source — keep full configuration.
+ * DOCKER_REGISTRY_SERVER_* may still appear when present in env.template.
+ *
  * @function filterConfigurationByRegistryMode
  * @param {Array} configuration - Environment configuration
- * @param {string} registryMode - Registry mode ('external' or 'internal')
- * @returns {Array} Filtered configuration
+ * @param {string} _registryMode - Registry mode ('external' or 'acr'); unused
+ * @returns {Array} Configuration unchanged
  */
-function filterConfigurationByRegistryMode(configuration, registryMode) {
-  if (registryMode !== 'external') {
-    return configuration;
-  }
-
-  const allowedDockerRegistryVars = [
-    'DOCKER_REGISTRY_SERVER_URL',
-    'DOCKER_REGISTRY_SERVER_USERNAME',
-    'DOCKER_REGISTRY_SERVER_PASSWORD'
-  ];
-  return configuration.filter(config => allowedDockerRegistryVars.includes(config.name));
+function filterConfigurationByRegistryMode(configuration, _registryMode) {
+  return Array.isArray(configuration) ? configuration : [];
 }
 
 function buildImageReference(variables) {

package/lib/infrastructure/index.js

@@ -203,12 +203,26 @@ async function removeAppVolumes(appNames, devId) {
   }
 }
 
+/**
+ * Resolve developer id for stop paths. Optional override is transient (not config).
+ * @param {string|number|null|undefined} developerId
+ * @returns {Promise<string>}
+ */
+async function resolveStopDeveloperId(developerId) {
+  if (developerId === undefined || developerId === null || developerId === '') {
+    return config.getDeveloperId();
+  }
+  const { validateAndNormalizeDeveloperId } = require('../core/config-normalize');
+  return validateAndNormalizeDeveloperId(developerId);
+}
+
 /**
  * Stops and removes local infrastructure services and all application containers
  * on the same network. Cleanly shuts down infra and app containers.
  *
  * @async
  * @function stopInfra
+ * @param {string|number|null|undefined} [developerId] - Optional target developer (does not change config)
  * @returns {Promise<void>} Resolves when infrastructure is stopped
  * @throws {Error} If Docker compose fails
  *
@@ -216,8 +230,8 @@ async function removeAppVolumes(appNames, devId) {
  * await stopInfra();
  * // All infrastructure and app containers on the same network are stopped and removed
  */
-async function stopInfra() {
-  const devId = await config.getDeveloperId();
+async function stopInfra(developerId) {
+  const devId = await resolveStopDeveloperId(developerId);
   const { infraDir, adminSecretsPath } = resolveInfraStatePaths(devId);
   const composePath = path.join(infraDir, 'compose.yaml');
   const hasCompose = fs.existsSync(composePath);
@@ -279,6 +293,7 @@ async function stopAllAppContainersAndVolumes(devId) {
  *
  * @async
  * @function stopInfraWithVolumes
+ * @param {string|number|null|undefined} [developerId] - Optional target developer (does not change config)
  * @returns {Promise<void>} Resolves when infrastructure is stopped and volumes removed
  * @throws {Error} If Docker compose fails
  *
@@ -286,8 +301,8 @@ async function stopAllAppContainersAndVolumes(devId) {
  * await stopInfraWithVolumes();
  * // All infrastructure and app containers and volumes are removed
  */
-async function stopInfraWithVolumes() {
-  const devId = await config.getDeveloperId();
+async function stopInfraWithVolumes(developerId) {
+  const devId = await resolveStopDeveloperId(developerId);
   const { infraDir, adminSecretsPath } = resolveInfraStatePaths(devId);
   const composePath = path.join(infraDir, 'compose.yaml');
   const hasCompose = fs.existsSync(composePath);