@aifabrix/builder 2.53.1 → 2.55.0

package/lib/commands/test-e2e-external.js

@@ -39,6 +39,99 @@ function deriveDatasourceKeyFromFileName(fileName, systemKey) {
 }
 
 /* eslint-disable max-statements -- Key resolution from system or files */
+function datasourceKeyFromParsedOrFile(parsed, fileName, systemKey) {
+  if (parsed && typeof parsed.key === 'string' && parsed.key.trim()) {
+    return parsed.key.trim();
+  }
+  return deriveDatasourceKeyFromFileName(fileName, systemKey);
+}
+
+function cipFetchSources(parsed) {
+  const ops = parsed && parsed.execution && parsed.execution.cip && parsed.execution.cip.operations;
+  if (!ops || typeof ops !== 'object') {
+    return [];
+  }
+  const sources = [];
+  for (const op of Object.values(ops)) {
+    if (!op || typeof op !== 'object') continue;
+    for (const step of op.steps || []) {
+      const src = step && step.fetch && step.fetch.source;
+      if (typeof src === 'string' && src.trim()) sources.push(src.trim());
+    }
+  }
+  return sources;
+}
+
+function isExclusiveRecordFetchSource(parsed) {
+  const sources = cipFetchSources(parsed);
+  return sources.length > 0 && sources.every((src) => src === 'record');
+}
+
+/**
+ * Maps datasource keys to E2E skip reasons (`view` / `record`) or storageType.
+ * @param {string} appPath
+ * @param {string[]} datasourceFiles
+ * @param {string} systemKey
+ * @returns {Object<string, string|undefined>}
+ */
+function loadDatasourceStorageByKey(appPath, datasourceFiles, systemKey) {
+  const byKey = {};
+  for (const fileName of datasourceFiles) {
+    const filePath = path.join(appPath, fileName);
+    if (!fs.existsSync(filePath)) continue;
+    try {
+      const parsed = loadConfigFile(filePath);
+      const key = datasourceKeyFromParsedOrFile(parsed, fileName, systemKey);
+      if (!key) continue;
+      if (parsed && parsed.storageType === 'view') byKey[key] = 'view';
+      else if (isExclusiveRecordFetchSource(parsed)) byKey[key] = 'record';
+      else byKey[key] = parsed && parsed.storageType;
+    } catch {
+      // Unreadable files stay unknown and remain eligible for E2E.
+    }
+  }
+  return byKey;
+}
+
+/**
+ * Table E2E (sync/CRUD) does not apply to viewpoint datasources.
+ * @param {string[]} keys
+ * @param {Object<string, string|undefined>} storageByKey
+ * @returns {{ runnable: string[], skipped: string[] }}
+ */
+function selectE2eRunnableKeys(keys, storageByKey) {
+  const runnable = [];
+  const skipped = [];
+  for (const key of keys) {
+    if (storageByKey[key] === 'view' || storageByKey[key] === 'record') skipped.push(key);
+    else runnable.push(key);
+  }
+  return { runnable, skipped };
+}
+
+/**
+ * Drops storageType view keys and logs skips. Empty runnable is success (nothing to run).
+ * @param {string} externalSystem
+ * @param {string} appPath
+ * @param {string[]} datasourceFiles
+ * @param {string} systemKey
+ * @param {string[]} keys
+ * @returns {string[]}
+ */
+function prepareE2eDatasourceKeys(externalSystem, appPath, datasourceFiles, systemKey, keys) {
+  const storageByKey = loadDatasourceStorageByKey(appPath, datasourceFiles, systemKey);
+  const { runnable, skipped } = selectE2eRunnableKeys(keys, storageByKey);
+  skipped.forEach((key) => {
+    const reason =
+      storageByKey[key] === 'record' ? 'fetch.source record' : 'storageType view';
+    logger.log(chalk.gray(`⏭ Skipping ${key} (${reason})`));
+  });
+  if (runnable.length === 0 && keys.length === 0) {
+    logger.log(chalk.yellow(`No datasources found for ${externalSystem}. Add datasource files and run aifabrix repair.`));
+  }
+  return runnable;
+}
+
 /**
  * Resolves the list of datasource keys for an external system (from system file or discovered files).
  * @param {string} appPath - Integration app path
@@ -117,22 +210,29 @@ async function syncLocalIfRequested(systemKey, options) {
   return uploadCtx && uploadCtx.dataplaneUrl && uploadCtx.authConfig ? uploadCtx : null;
 }
 
-/* eslint-disable max-lines-per-function, max-statements -- Load context, then loop over keys */
-/**
- * Runs E2E for all datasources of an external system. Uses each datasource's payloadTemplate (no extra params required).
- *
- * @async
- * @param {string} externalSystem - System key (e.g. hubspot-demo)
- * @param {Object} options - Options passed to each runDatasourceTestE2E
- * @param {string} [options.env] - Environment (dev, tst, pro)
- * @param {boolean} [options.debug] - Include debug, write log
- * @param {boolean} [options.verbose] - Verbose output
- * @param {boolean} [options.async] - If false, sync mode (default true)
- * @param {boolean} [options.noPublish] - When true, skip upload (E2E uses dataplane config already deployed)
- * @returns {Promise<{ success: boolean, results: Array<{ key: string, success: boolean, error?: string }> }>}
- */
+function isPlatformShellAppPath(appPath) {
+  const parent = path.basename(path.dirname(path.resolve(String(appPath || ''))));
+  return parent === 'role-assistant' || parent === 'enterprise-knowledge';
+}
+
+function platformShellIntegrationContext(systemKey, appPath) {
+  return { systemKey, keys: [], appPath, datasourceFiles: [] };
+}
+
+function tryApplicationConfigPath(appPath) {
+  try {
+    return resolveApplicationConfigPath(appPath);
+  } catch (error) {
+    if (isPlatformShellAppPath(appPath)) {
+      return null;
+    }
+    throw error;
+  }
+}
+
 /**
  * Resolve integration folder, system key, and datasource keys for system-level tests.
+ * Role Assistant / Enterprise Knowledge packages have no application.yaml.
  * @param {string} externalSystem
  * @returns {{ systemKey: string, keys: string[] }}
  */
@@ -144,13 +244,19 @@ function resolveExternalIntegrationContext(externalSystem, pathOptions = {}) {
   if (!fs.existsSync(appPath)) {
     throw new Error(`Integration path not found: ${appPath}`);
   }
-  const configPath = resolveApplicationConfigPath(appPath);
+  const configPath = tryApplicationConfigPath(appPath);
+  if (!configPath) {
+    return platformShellIntegrationContext(externalSystem, appPath);
+  }
   let variables = {};
   if (fs.existsSync(configPath)) {
     variables = loadConfigFile(configPath);
   }
   const { systemFiles, datasourceFiles: discovered } = discoverIntegrationFiles(appPath);
   if (systemFiles.length === 0) {
+    if (isPlatformShellAppPath(appPath)) {
+      return platformShellIntegrationContext(externalSystem, appPath);
+    }
     throw new Error(`No system file found in ${appPath}. Expected *-system.yaml or *-system.json`);
   }
   const datasourceFiles = buildEffectiveDatasourceFiles(
@@ -171,13 +277,33 @@ function resolveExternalIntegrationContext(externalSystem, pathOptions = {}) {
     systemParsed,
     datasourceFiles
   );
-  return { systemKey, keys };
+  return { systemKey, keys, appPath, datasourceFiles };
 }
 
+/* eslint-disable max-lines-per-function, max-statements -- Load context, then loop over keys */
+/**
+ * Runs E2E for all datasources of an external system. Uses each datasource's payloadTemplate (no extra params required).
+ *
+ * @async
+ * @param {string} externalSystem - System key (e.g. hubspot-demo)
+ * @param {Object} options - Options passed to each runDatasourceTestE2E
+ * @param {string} [options.env] - Environment (dev, tst, pro)
+ * @param {boolean} [options.debug] - Include debug, write log
+ * @param {boolean} [options.verbose] - Verbose output
+ * @param {boolean} [options.async] - If false, sync mode (default true)
+ * @param {boolean} [options.noPublish] - When true, skip upload (E2E uses dataplane config already deployed)
+ * @returns {Promise<{ success: boolean, results: Array<{ key: string, success: boolean, error?: string }> }>}
+ */
 async function runTestE2EForExternalSystem(externalSystem, options = {}) {
-  const { systemKey, keys } = resolveExternalIntegrationContext(externalSystem);
-  if (keys.length === 0) {
-    logger.log(chalk.yellow(`No datasources found for ${externalSystem}. Add datasource files and run aifabrix repair.`));
+  const { systemKey, keys, appPath, datasourceFiles } = resolveExternalIntegrationContext(externalSystem);
+  const e2eKeys = prepareE2eDatasourceKeys(
+    externalSystem,
+    appPath,
+    datasourceFiles,
+    systemKey,
+    keys
+  );
+  if (e2eKeys.length === 0) {
     return { success: true, results: [] };
   }
 
@@ -217,12 +343,12 @@ async function runTestE2EForExternalSystem(externalSystem, options = {}) {
     quietPollUi: options.quietPollUi === true,
     onPollProgress: options.onPollProgress
   };
-  for (const key of keys) {
+  for (const key of e2eKeys) {
     if (typeof options.onDatasourceProgress === 'function') {
       options.onDatasourceProgress({
         key,
         index: results.length,
-        total: keys.length
+        total: e2eKeys.length
       });
     }
     try {
@@ -246,6 +372,7 @@ async function runTestE2EForExternalSystem(externalSystem, options = {}) {
 module.exports = {
   runTestE2EForExternalSystem,
   getDatasourceKeys,
+  selectE2eRunnableKeys,
   resolveExternalIntegrationContext,
   syncLocalIfRequested
 };

package/lib/commands/test-trust-external.js

@@ -25,11 +25,13 @@ const {
 async function runTestTrustForExternalSystem(externalSystem, options = {}) {
   const { systemKey } = resolveExternalIntegrationContext(externalSystem);
 
-  const uploadCtx = await syncLocalIfRequested(systemKey, options);
-  if (uploadCtx?.authConfig && uploadCtx?.dataplaneUrl) {
-    options.authConfig = uploadCtx.authConfig;
-    options.dataplaneUrl = uploadCtx.dataplaneUrl;
-    options.silentResolve = true;
+  if (options.upload === true && options.noPublish !== true) {
+    const uploadCtx = await syncLocalIfRequested(systemKey, options);
+    if (uploadCtx?.authConfig && uploadCtx?.dataplaneUrl) {
+      options.authConfig = uploadCtx.authConfig;
+      options.dataplaneUrl = uploadCtx.dataplaneUrl;
+      options.silentResolve = true;
+    }
   }
   if (options.revalidate === true) {
     logger.log(chalk.cyan('Forcing revalidation (cache bypass)…'));

package/lib/commands/upload-credential-push-log.js

@@ -91,7 +91,8 @@ async function pushAndLogCredentialSecrets(dataplaneUrl, authConfig, systemKey,
       pushCredentialSecrets(dataplaneUrl, authConfig, {
         envFilePath,
         appName: systemKey,
-        payload
+        payload,
+        excludeKeys: uiOpts.excludeSecretKeys
       }),
     { systemKey, json: uiOpts.json === true }
   );

package/lib/commands/upload-publish-context.js

@@ -57,7 +57,7 @@ async function resolveUploadPublishContext(
     environment: options.environment
   });
   requireBearerForDataplanePipeline(resolved.authConfig);
-  if (options.force === true) {
+  if (options.force === true && options.suppressSummary !== true) {
     logForcePublishWarning();
   }
   const controllerUrl = await resolveControllerUrl();

package/lib/commands/upload-role-assistant-shell.js

@@ -0,0 +1,124 @@
+/**
+ * Role Assistant upload without Connected System files.
+ *
+ * @fileoverview Settings + Evidence path for role-assistant/ packages
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { detectAppType } = require('../utils/paths');
+const { isRoleAssistantWorkspace } = require('../utils/platform-shell-package');
+const {
+  SYSTEM_KIND_DIGITAL_WORKER,
+  readRoleAssistantSettings,
+  resolveRoleAssistantSettingsVersion,
+  resolveRoleAssistantEnvironmentSettings
+} = require('../role-assistant/settings');
+const { validateExternalSystemComplete } = require('../validation/validate');
+const { displayValidationResults } = require('../validation/validate-display');
+const { formatSuccessLine } = require('../utils/cli-test-layout-chalk');
+const { runUploadSidecarFollowups } = require('./upload-sidecar-followups');
+const { finalizeUploadPublishResult } = require('./upload-data-sync-finalize');
+
+async function isRoleAssistantShellPackage(systemKey, options = {}) {
+  const pathOptions = options.pathOptions || {};
+  const detected = await detectAppType(systemKey, pathOptions);
+  return isRoleAssistantWorkspace(detected.baseDir);
+}
+
+function buildRoleAssistantShellPayload(systemKey, options = {}) {
+  const pathOptions = options.pathOptions || {};
+  const settings = readRoleAssistantSettings(systemKey, { required: true, pathOptions });
+  resolveRoleAssistantEnvironmentSettings(settings, options.env || 'dev', { required: true });
+  const version = resolveRoleAssistantSettingsVersion(settings) || '1.0.0';
+  return {
+    version,
+    application: {
+      key: systemKey,
+      systemKind: SYSTEM_KIND_DIGITAL_WORKER
+    },
+    dataSources: [],
+    status: options.uploadStatus === 'published' ? 'published' : 'draft'
+  };
+}
+
+function assertRoleAssistantShellValid(validationResult) {
+  if (validationResult && validationResult.valid) {
+    return;
+  }
+  displayValidationResults(validationResult);
+  const errors = (validationResult && validationResult.errors) || [];
+  const summary = errors.slice(0, 3).map((item) => (typeof item === 'string' ? item : String(item))).join('; ');
+  throw new Error(
+    summary
+      ? `Validation failed: ${summary}. Fix errors above and run the command again.`
+      : 'Validation failed. Fix errors before uploading.'
+  );
+}
+
+async function validateRoleAssistantShellPackage(systemKey, options = {}) {
+  const pathOptions = options.pathOptions || {};
+  const validationResult = await validateExternalSystemComplete(systemKey, {
+    type: 'external',
+    ...pathOptions
+  });
+  assertRoleAssistantShellValid(validationResult);
+  if (options.minimal !== true) {
+    logger.log(formatSuccessLine('Local validation passed'));
+  }
+}
+
+function logRoleAssistantShellDryRun(systemKey, payload) {
+  logger.log(
+    chalk.yellow(
+      'Dry run: would apply Role Assistant settings and Evidence (no Connected System publish).'
+    )
+  );
+  logger.log(chalk.gray(`  System: ${systemKey}, version: ${payload.version}`));
+}
+
+async function applyRoleAssistantShellSidecars(systemKey, options, payload, deps) {
+  const { dataplaneUrl, authConfig, environment } = await deps.resolveDataplaneAndAuth(
+    systemKey,
+    options
+  );
+  const sidecar = await runUploadSidecarFollowups({
+    systemKey,
+    options: { ...options, skipDataSync: true },
+    payload,
+    dataplaneUrl,
+    authConfig,
+    environment
+  });
+  if (options.suppressSummary !== true && options.minimal !== true) {
+    logger.log(
+      formatSuccessLine('Role Assistant settings and Evidence applied (no Connected System publish).')
+    );
+  }
+  return finalizeUploadPublishResult(
+    { dataplaneUrl, authConfig, environment, uploadSkipped: true, sidecar },
+    payload,
+    options
+  );
+}
+
+async function uploadRoleAssistantShellPackage(systemKey, options = {}, deps = {}) {
+  if (!deps.resolveDataplaneAndAuth) {
+    throw new Error('Role Assistant upload requires dataplane auth resolution');
+  }
+  await validateRoleAssistantShellPackage(systemKey, options);
+  const payload = buildRoleAssistantShellPayload(systemKey, options);
+  if (options.dryRun === true) {
+    logRoleAssistantShellDryRun(systemKey, payload);
+    return undefined;
+  }
+  return applyRoleAssistantShellSidecars(systemKey, options, payload, deps);
+}
+
+module.exports = {
+  isRoleAssistantShellPackage,
+  buildRoleAssistantShellPayload,
+  uploadRoleAssistantShellPackage
+};

package/lib/commands/upload-sidecar-followups.js

@@ -38,11 +38,14 @@ function buildRoleAssistantSyncContext(ctx, model) {
 
 async function runGovernanceSidecar(ctx, sidecar, quietSidecar) {
   try {
-    const { uploadGovernanceScenarioPacks } = require('../lifecycle/scenario-upload');
-    const uploaded = await uploadGovernanceScenarioPacks(ctx.systemKey, ctx.dataplaneUrl, ctx.authConfig, {
+    const {
+      uploadGovernanceScenarioPacks,
+      normalizeGovernanceUploadResult
+    } = require('../lifecycle/scenario-upload');
+    const result = await uploadGovernanceScenarioPacks(ctx.systemKey, ctx.dataplaneUrl, ctx.authConfig, {
       silent: quietSidecar
     });
-    sidecar.governance = { uploaded: Number(uploaded || 0) };
+    sidecar.governance = normalizeGovernanceUploadResult(result);
   } catch (err) {
     sidecar.governance = { skipped: true, reason: err.message || String(err) };
     if (!quietSidecar) {
@@ -114,7 +117,8 @@ async function runUploadSidecarFollowups(ctx) {
     governance: null,
     evidence: null,
     knowledge: null,
-    documentStorageSettings: null
+    documentStorageSettings: null,
+    tests: null
   };
   const quietSidecar = isQuietMinimalSync(ctx.options);
   const model = buildRoleAssistantModel(ctx.payload);
@@ -128,6 +132,8 @@ async function runUploadSidecarFollowups(ctx) {
     throw err;
   }
   await runKnowledgeSidecar(ctx, model, sidecar, quietSidecar);
+  const { runTestsSidecar } = require('../role-assistant/test-pack-sync');
+  await runTestsSidecar(ctx, sidecar, quietSidecar);
   return sidecar;
 }
 

package/lib/commands/upload.js

@@ -44,6 +44,7 @@ const { maybeSyncOpenApiFilesForMcp } = require('./repair-openapi-sync');
 const { exportProgrammaticOpenApiForRepair } = require('./repair-openapi-export');
 const { resolveUploadPublishContext } = require('./upload-publish-context');
 const { syncDeployJsonFromSources } = require('../external-system/sync-deploy-manifest');
+const { assertUploadPackageIdentity } = require('../external-system/upload-identity');
 const { handlePublicationAndFollowups } = require('./upload-sidecar-followups');
 const { finalizeUploadPublishResult, finishUnchangedUploadPublication } = require('./upload-data-sync-finalize');
 const { pushAndLogCredentialSecrets } = require('./upload-credential-push-log');
@@ -53,6 +54,10 @@ const {
   resolveRoleAssistantSettingsVersion,
   resolveRoleAssistantEnvironmentSettings
 } = require('../role-assistant/settings');
+const {
+  isRoleAssistantShellPackage,
+  uploadRoleAssistantShellPackage
+} = require('./upload-role-assistant-shell');
 
 /**
  * Validates system-key format (same as download).
@@ -149,7 +154,10 @@ async function runUploadValidatePublish(
     { timeoutMs: options.timeoutMs }
   );
   if (res?.success === false) {
-    throw new Error(formatApiError(res, dataplaneUrl));
+    const err = new Error(formatApiError(res, dataplaneUrl));
+    const status = Number(res.status || res.statusCode);
+    err.statusCode = status >= 400 && status < 600 ? status : 400;
+    throw err;
   }
   return res;
 }
@@ -256,6 +264,7 @@ async function buildValidatedUploadManifestPayload(systemKey, opts = {}) {
     }
   }
   await resolvePayloadConfiguration(systemKey, payload, pathOptions);
+  assertUploadPackageIdentity(payload, systemKey);
   return { manifest, payload };
 }
 
@@ -312,7 +321,8 @@ async function completeUploadAfterPublish(systemKey, options, manifest, payload,
   const pushMeta = await pushAndLogCredentialSecrets(ctx.dataplaneUrl, ctx.authConfig, systemKey, payload, {
     json: options.json === true,
     pathOptions: options.pathOptions,
-    suppressCredentialLog: quietCompact
+    suppressCredentialLog: quietCompact,
+    excludeSecretKeys: options.excludeSecretKeys
   });
   await logAndSyncLocalOpenApiForUpload(systemKey, manifest, {
     dataplaneUrl: ctx.dataplaneUrl,
@@ -417,7 +427,12 @@ async function uploadExternalSystem(systemKey, options = {}) {
       : options.minimal === false
         ? false
         : options.verbose !== true;
-  const uploadOptions = { ...options, minimal };
+  const uploadOptions = { ...options, minimal, pathOptions };
+  if (await isRoleAssistantShellPackage(systemKey, uploadOptions)) {
+    return uploadRoleAssistantShellPackage(systemKey, uploadOptions, {
+      resolveDataplaneAndAuth
+    });
+  }
   if (!minimal) {
     logger.log('');
     logger.log(sectionTitle('Upload external system'));

package/lib/commands/verify-operations-skip-e2e.js

@@ -0,0 +1,131 @@
+/**
+ * When verify-operations should skip live E2E (Role Assistant or static custom).
+ *
+ * @fileoverview Skip E2E for packages that have no live vendor pull
+ */
+
+'use strict';
+
+const path = require('path');
+const { loadConfigFile } = require('../utils/config-format');
+const { discoverIntegrationFiles } = require('./repair-internal');
+
+const STORAGE_ENTITY_TYPES = new Set(['recordStorage', 'documentStorage']);
+
+/**
+ * Role Assistant packages use authType none + nested builder-api CIP.
+ * Live capacity E2E expects a system baseUrl credential and is not the RA certify path.
+ * @param {string} systemKey
+ * @param {Object} options
+ * @returns {boolean}
+ */
+function shouldSkipE2eForRoleAssistant(systemKey, options) {
+  if (options.forceE2e === true) {
+    return false;
+  }
+  try {
+    const { resolveAppWorkspace } = require('../utils/app-path-resolve');
+    const { baseDir } = resolveAppWorkspace(systemKey, {});
+    return baseDir === 'role-assistant';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {string} filePath
+ * @returns {Object|null}
+ */
+function readManifestObject(filePath) {
+  try {
+    const parsed = loadConfigFile(filePath);
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {string} appPath
+ * @param {string} systemKey
+ * @returns {string|null}
+ */
+function readLocalSystemType(appPath, systemKey) {
+  const candidates = [
+    path.join(appPath, `${systemKey}-system.json`),
+    path.join(appPath, `${systemKey}-system.yaml`),
+    path.join(appPath, `${systemKey}-system.yml`)
+  ];
+  for (const filePath of candidates) {
+    const doc = readManifestObject(filePath);
+    if (doc && typeof doc.type === 'string' && doc.type.trim()) {
+      return doc.type.trim().toLowerCase();
+    }
+  }
+  return null;
+}
+
+/**
+ * @param {string} appPath
+ * @returns {Object[]}
+ */
+function loadStorageDatasources(appPath) {
+  const { datasourceFiles } = discoverIntegrationFiles(appPath);
+  const storage = [];
+  for (const name of datasourceFiles) {
+    const doc = readManifestObject(path.join(appPath, name));
+    if (!doc || !STORAGE_ENTITY_TYPES.has(String(doc.entityType || ''))) {
+      continue;
+    }
+    storage.push(doc);
+  }
+  return storage;
+}
+
+/**
+ * Static custom packages (syncBridge disabled) have no live vendor pull.
+ * @param {string} systemKey
+ * @param {Object} options
+ * @returns {boolean}
+ */
+function shouldSkipE2eForStaticPackage(systemKey, options) {
+  if (options.forceE2e === true) {
+    return false;
+  }
+  try {
+    const { resolveAppWorkspace } = require('../utils/app-path-resolve');
+    const { baseDir, appPath } = resolveAppWorkspace(systemKey, options);
+    if (baseDir !== 'integration' || !appPath) {
+      return false;
+    }
+    if (readLocalSystemType(appPath, systemKey) !== 'custom') {
+      return false;
+    }
+    const storage = loadStorageDatasources(appPath);
+    if (storage.length === 0) {
+      return false;
+    }
+    return storage.every((ds) => String(ds.syncBridge || 'disabled').toLowerCase() === 'disabled');
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {string} systemKey
+ * @param {Object} options
+ * @returns {boolean}
+ */
+function shouldSkipOperationsE2e(systemKey, options) {
+  if (options.skipE2e === true || options.minimal === true) {
+    return true;
+  }
+  return shouldSkipE2eForRoleAssistant(systemKey, options)
+    || shouldSkipE2eForStaticPackage(systemKey, options);
+}
+
+module.exports = {
+  shouldSkipOperationsE2e,
+  shouldSkipE2eForRoleAssistant,
+  shouldSkipE2eForStaticPackage
+};

package/lib/commands/verify-operations-step-plan.js

@@ -7,6 +7,7 @@
 const { validateExternalSystemComplete } = require('../validation/validate');
 const { testExternalSystem, testExternalSystemIntegration } = require('../external-system/test');
 const { runTestE2EForExternalSystem } = require('./test-e2e-external');
+const { shouldSkipOperationsE2e } = require('./verify-operations-skip-e2e');
 
 /**
  * @param {string} systemKey
@@ -59,21 +60,13 @@ function buildAfterSyncSteps(systemKey, options) {
  * @returns {Object}
  */
 function buildE2eStep(systemKey, options) {
-  if (options.skipE2e === true || options.minimal === true) {
+  if (shouldSkipOperationsE2e(systemKey, options)) {
+    const reason = options.skipE2e === true || options.minimal === true
+      ? 'minimal'
+      : 'static-or-role-assistant';
     return {
       key: 'e2e',
-      run: async() => ({ success: true, skipped: true, reason: 'minimal' }),
-      ok: () => true
-    };
-  }
-  if (shouldSkipE2eForRoleAssistant(systemKey, options)) {
-    return {
-      key: 'e2e',
-      run: async() => ({
-        success: true,
-        skipped: true,
-        reason: 'role-assistant-auth-none'
-      }),
+      run: async() => ({ success: true, skipped: true, reason }),
       ok: () => true
     };
   }
@@ -99,26 +92,6 @@ function buildE2eStep(systemKey, options) {
   };
 }
 
-/**
- * Role Assistant packages use authType none + nested builder-api CIP.
- * Live capacity E2E expects a system baseUrl credential and is not the RA certify path.
- * @param {string} systemKey
- * @param {Object} options
- * @returns {boolean}
- */
-function shouldSkipE2eForRoleAssistant(systemKey, options) {
-  if (options.forceE2e === true) {
-    return false;
-  }
-  try {
-    const { resolveAppWorkspace } = require('../utils/app-path-resolve');
-    const { baseDir } = resolveAppWorkspace(systemKey, {});
-    return baseDir === 'role-assistant';
-  } catch {
-    return false;
-  }
-}
-
 /**
  * @param {string} systemKey
  * @param {Object} options