@aifabrix/builder 2.53.1 → 2.55.0

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

@@ -12,6 +12,7 @@ const fs = require('../internal/fs-real-sync');
 const path = require('path');
 const { ensureIntegrationDirectory } = require('./workspace-context');
 const { resolveChannelRuntimeValues } = require('../channels/channel-runtime-resolver');
+const { vendorFacingUrlsFromCtx } = require('../channels/vendor-dataplane-url');
 const { generateChannelArtifact } = require('../channels/channel-artifact-generator');
 const { loadChannelPackageContext } = require('../channels/channel-discovery');
 const {
@@ -20,6 +21,10 @@ const {
   mergeChannelBranding
 } = require('../channels/channel-branding');
 const { isChannelTargetKey } = require('../channels/channel-targets');
+const {
+  httpError,
+  readChannelInstallSessionForDefinition
+} = require('./channel-install-session');
 
 /**
  * @param {import('./workspace-context').WorkspaceContext} ctx
@@ -43,6 +48,16 @@ function requireChannelTarget(systemKey) {
   return systemKey;
 }
 
+/**
+ * Catalog packaging key: instance paths (name slug) still read dist/channels/<catalog>/.
+ * @param {import('./workspace-context').WorkspaceContext} ctx
+ * @returns {string}
+ */
+function packagingChannelTarget(ctx) {
+  const { resolveInstallDefinitionKey } = require('./channel-install-help-resolve');
+  return requireChannelTarget(resolveInstallDefinitionKey(ctx));
+}
+
 /**
  * @param {import('./workspace-context').WorkspaceContext} ctx
  * @returns {{ type: string, token: string }}
@@ -82,8 +97,13 @@ function generatePackageArtifact(ctx, body, channelTarget, branding, dataplaneUr
     branding.displayName || body.name || packageContext.displayName || channelTarget;
   const description =
     branding.description || body.description || packageContext.description || '';
+  const vendor = vendorFacingUrlsFromCtx({
+    ...ctx,
+    dataplaneUrl
+  });
   const runtimeValues = resolveChannelRuntimeValues({
-    dataplaneBaseUrl: dataplaneUrl,
+    dataplaneBaseUrl: vendor.dataplaneBaseUrl,
+    controllerUrl: vendor.controllerUrl,
     channelTarget,
     appName,
     baseName: body.baseName || appName,
@@ -91,6 +111,7 @@ function generatePackageArtifact(ctx, body, channelTarget, branding, dataplaneUr
     appDescription: description,
     layerBToolNames: packageContext.governedToolNames || [],
     packageContext,
+    oauthPluginVaultReferenceId: body.oauthPluginVaultReferenceId,
     iconColorPath: branding.iconColorPath,
     iconOutlinePath: branding.iconOutlinePath
   });
@@ -108,7 +129,7 @@ function generatePackageArtifact(ctx, body, channelTarget, branding, dataplaneUr
  * @returns {Promise<Object>}
  */
 async function buildChannelPackage(ctx, body = {}) {
-  const channelTarget = requireChannelTarget(ctx.systemKey);
+  const channelTarget = packagingChannelTarget(ctx);
   ensureIntegrationDirectory(ctx);
   const dir = workspaceSystemDir(ctx);
   const branding = mergeChannelBranding(readChannelBranding(dir), body.branding || {});
@@ -151,7 +172,7 @@ async function buildChannelPackage(ctx, body = {}) {
  * @returns {Object}
  */
 function getChannelPackageSummary(ctx) {
-  const channelTarget = requireChannelTarget(ctx.systemKey);
+  const channelTarget = packagingChannelTarget(ctx);
   const projectRoot = ctx.getUserRoot();
   const summaryPath = path.join(
     projectRoot,
@@ -161,7 +182,7 @@ function getChannelPackageSummary(ctx) {
     `channel-${channelTarget}.json`
   );
   if (!fs.existsSync(summaryPath)) {
-    throw new Error(`Channel package summary not found: ${summaryPath}`);
+    throw httpError(`Channel package summary not found: ${summaryPath}`, 404);
   }
   const summary = JSON.parse(fs.readFileSync(summaryPath, 'utf8'));
   return {
@@ -177,8 +198,8 @@ function getChannelPackageSummary(ctx) {
  * @param {import('./workspace-context').WorkspaceContext} ctx
  * @returns {{ fileName: string, contentType: string, byteLength: number, zipBase64: string }}
  */
-function getChannelPackageZip(ctx) {
-  const channelTarget = requireChannelTarget(ctx.systemKey);
+function readChannelPackageZip(ctx) {
+  const channelTarget = packagingChannelTarget(ctx);
   const summary = getChannelPackageSummary(ctx).summary;
   const zipPath =
     typeof summary?.links?.zip === 'string' && summary.links.zip
@@ -192,7 +213,7 @@ function getChannelPackageZip(ctx) {
         `appPackage.${summary.environment || 'dev'}.zip`
       );
   if (!fs.existsSync(zipPath)) {
-    throw new Error(`Channel package ZIP not found: ${zipPath}`);
+    throw httpError(`Channel package ZIP not found: ${zipPath}`, 404);
   }
   const buffer = fs.readFileSync(zipPath);
   return {
@@ -203,6 +224,65 @@ function getChannelPackageZip(ctx) {
   };
 }
 
+/**
+ * @param {Object|null} session
+ * @returns {Object}
+ */
+function packageBodyFromSession(session) {
+  if (!session || typeof session !== 'object') {
+    return {};
+  }
+  return {
+    name: session.displayName || session.name,
+    oauthPluginVaultReferenceId: session.oauthPluginVaultReferenceId
+  };
+}
+
+/**
+ * Portal ZIP GET must not 500 with CLI `--oauth-plugin-vault-reference-id` text.
+ * @param {unknown} err
+ * @returns {unknown}
+ */
+function mapCopilotPackageHttpError(err) {
+  if (err && err.statusCode) {
+    return err;
+  }
+  const msg = String((err && err.message) || '');
+  if (/oauth-plugin-vault-reference-id|OAuthPluginVault/i.test(msg)) {
+    return httpError(
+      'Copilot app package is not ready until Teams Entra SSO registration is stored on this install.',
+      409
+    );
+  }
+  return err;
+}
+
+/**
+ * Rebuild the Copilot ZIP when the workspace lost dist/ after an image recreate.
+ * @param {import('./workspace-context').WorkspaceContext} ctx
+ * @returns {Promise<{ fileName: string, contentType: string, byteLength: number, zipBase64: string }>}
+ */
+async function getChannelPackageZip(ctx) {
+  let summaryMissing = false;
+  try {
+    getChannelPackageSummary(ctx);
+  } catch (err) {
+    if (!err || err.statusCode !== 404) {
+      throw mapCopilotPackageHttpError(err);
+    }
+    summaryMissing = true;
+  }
+  if (summaryMissing) {
+    try {
+      const session = readChannelInstallSessionForDefinition(ctx, packagingChannelTarget(ctx));
+      await buildChannelPackage(ctx, packageBodyFromSession(session));
+    } catch (err) {
+      throw mapCopilotPackageHttpError(err);
+    }
+  }
+  return readChannelPackageZip(ctx);
+}
+
 /**
  * @param {import('./workspace-context').WorkspaceContext} ctx
  * @param {Object} body

package/lib/programmatic/run-download.js

@@ -0,0 +1,41 @@
+/**
+ * Programmatic download wrapper — CLI download parity for builder-api.
+ *
+ * @fileoverview runDownload for POST /systems/:systemKey/download
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { downloadExternalSystem } = require('../external-system/download');
+const { runWithWorkspaceContext } = require('./workspace-context');
+const { mergeProgrammaticOptions } = require('./command-options');
+const { touchWorkspaceMeta } = require('./workspace-meta');
+
+/**
+ * @param {import('./workspace-context').WorkspaceContext} ctx
+ * @param {Object} [options]
+ * @param {boolean} [options.force]
+ * @param {boolean} [options.dryRun]
+ * @param {string} [options.format]
+ * @returns {Promise<Object>}
+ */
+async function runDownload(ctx, options = {}) {
+  const merged = mergeProgrammaticOptions(ctx, options);
+  return runWithWorkspaceContext(ctx, async() => {
+    await downloadExternalSystem(ctx.systemKey, merged);
+    if (!options.dryRun) {
+      touchWorkspaceMeta(ctx, { lastOperation: 'download' });
+    }
+    return {
+      downloaded: options.dryRun !== true,
+      dryRun: options.dryRun === true,
+      systemKey: ctx.systemKey
+    };
+  });
+}
+
+module.exports = {
+  runDownload
+};

package/lib/programmatic/workspace-context.js

@@ -51,6 +51,7 @@ function resolveWorkspaceRoot(segment) {
  * @param {string} [params.environment]
  * @param {string} [params.controllerUrl]
  * @param {string} [params.dataplaneUrl]
+ * @param {string} [params.publicOrigin]
  * @returns {WorkspaceContext}
  */
 function createWorkspaceContext(params) {
@@ -88,6 +89,7 @@ function createWorkspaceContext(params) {
       process.env.CONTROLLER_URL ||
       '',
     dataplaneUrl: params.dataplaneUrl || process.env.DATAPLANE_URL || '',
+    publicOrigin: typeof params.publicOrigin === 'string' ? params.publicOrigin.trim() : '',
     bearerToken,
     getUserRoot: () => userRoot,
     getIntegrationRoot: () => integrationRoot,

package/lib/protection/auth-context.js

@@ -67,7 +67,9 @@ async function resolveCliProtectionDataplaneContext(options) {
     throw new Error('Authentication required. Run "aifabrix login" and try again.');
   }
 
-  const dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig);
+  const dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig, {
+    silent: options.json === true || options.silent === true
+  });
   return { environment, controllerUrl, dataplaneUrl, authConfig };
 }
 

package/lib/protection/protection-display.js

@@ -18,7 +18,7 @@ const {
   formatProgress,
   formatNextActions
 } = require('../utils/cli-test-layout-chalk');
-const { reportTaskRows } = require('./report-exit');
+const { reportTaskRows, isProtectionProblemResponse } = require('./report-exit');
 const { describeProtectionRoot } = require('./paths');
 const {
   appendTaskRows,
@@ -46,7 +46,8 @@ function formatProtectionValidateTTY(report, opts = {}) {
   const meta = report?.metadata || {};
   appendProtectionReportHeader(lines, meta);
   const summary = report?.summary || {};
-  const failCount = Number(summary.fail || 0);
+  const problem = isProtectionProblemResponse(report);
+  const failCount = problem ? Math.max(1, Number(summary.fail || 0)) : Number(summary.fail || 0);
   const warnCount = Number(summary.warn || 0);
   const aggregate = failCount > 0 ? 'fail' : warnCount > 0 ? 'warn' : 'ok';
   const glyph = aggregate === 'fail' ? '✖' : aggregate === 'warn' ? '⚠' : '✔';

package/lib/protection/report-exit.js

@@ -23,6 +23,51 @@ function reportTaskRows(report) {
   return [];
 }
 
+/**
+ * True when the payload is an RFC 7807 / API-client error, not a validate report.
+ * @param {*} report
+ * @returns {boolean}
+ */
+function isProtectionProblemResponse(report) {
+  if (!report || typeof report !== 'object') {
+    return false;
+  }
+  if (report.success === false) {
+    return true;
+  }
+  const status = Number(report.statusCode || report.status);
+  if (Number.isFinite(status) && status >= 400) {
+    return true;
+  }
+  const type = typeof report.type === 'string' ? report.type : '';
+  return type.includes('/Errors/') || type.includes('application/problem');
+}
+
+/**
+ * @param {*} uploaded
+ * @returns {string}
+ */
+function protectionUploadFailureMessage(uploaded) {
+  if (!uploaded || typeof uploaded !== 'object') {
+    return 'Protection upload returned empty response';
+  }
+  return (
+    uploaded.formattedError ||
+    uploaded.error ||
+    uploaded.detail ||
+    `Protection upload failed (HTTP ${uploaded.statusCode || uploaded.status || 0})`
+  );
+}
+
+/**
+ * @param {*} uploaded
+ */
+function assertProtectionUploadSucceeded(uploaded) {
+  if (!uploaded || typeof uploaded !== 'object' || isProtectionProblemResponse(uploaded)) {
+    throw new Error(protectionUploadFailureMessage(uploaded));
+  }
+}
+
 /**
  * @param {Object} report
  * @param {Object} [opts]
@@ -33,6 +78,9 @@ function exitCodeFromProtectionReport(report, opts = {}) {
   if (!report || typeof report !== 'object') {
     return 3;
   }
+  if (isProtectionProblemResponse(report)) {
+    return 1;
+  }
   const summary = report.summary || {};
   const failCount = Number(summary.fail || 0);
   const warnCount = Number(summary.warn || 0);
@@ -58,5 +106,7 @@ function exitCodeFromProtectionReport(report, opts = {}) {
 
 module.exports = {
   reportTaskRows,
+  isProtectionProblemResponse,
+  assertProtectionUploadSucceeded,
   exitCodeFromProtectionReport
 };

package/lib/protection/run-commands.js

@@ -18,6 +18,7 @@ const {
   deleteProtection,
   findProtectionKeyByDatasource
 } = require('../api/protection.api');
+const { assertProtectionUploadSucceeded } = require('./report-exit');
 const { preflightDatasourceReady } = require('./preflight-datasource-ready');
 const { runProtectionUploadDataSync } = require('./run-commands-upload-sync');
 const {
@@ -63,6 +64,7 @@ async function runProtectionUpload(datasourceKey, manifest, opts, logger) {
 
   logger.log(formatProgress('Uploading protection manifest...'));
   const uploaded = await uploadProtection(ctx.dataplaneUrl, ctx.authConfig, manifest);
+  assertProtectionUploadSucceeded(uploaded);
   logger.log(
     formatSuccessLine(
       `Protection for '${datasourceKey}' uploaded (deploymentId ${uploaded?.deploymentId || '—'}, revision ${uploaded?.revision ?? '—'})`

package/lib/role-assistant/evidence-sync.js

@@ -22,6 +22,7 @@ const {
 } = require('../api/evidence.api');
 const { resolveExternalSystemPath } = require('../utils/app-path-resolve');
 const { SYSTEM_KIND_DIGITAL_WORKER } = require('./settings');
+const { formatEvidenceValidationIssues } = require('./evidence-validation-issues');
 
 const EVIDENCE_DIR_NAME = 'evidence';
 const EVIDENCE_EXPORT_FILE = 'evidence.json';
@@ -288,8 +289,9 @@ function isActivatedEvidenceRow(row) {
 async function runEvidenceLifecycleForRef(dataplaneUrl, authConfig, evidenceRef) {
   const validation = await validateEvidenceCandidate(dataplaneUrl, authConfig, evidenceRef);
   if (validationFailed(validation)) {
-    const issues = Array.isArray(validation?.issues) ? validation.issues.length : 0;
-    throw new Error(`Validation failed for evidence ${evidenceRef} (${issues} issue${issues === 1 ? '' : 's'}).`);
+    throw new Error(
+      `Validation failed for evidence ${evidenceRef} (${formatEvidenceValidationIssues(validation?.issues)}).`
+    );
   }
   if (String(validation?.status || '').trim().toLowerCase() !== VALIDATION_PASSED) {
     throw new Error(`Validation status for evidence ${evidenceRef} is "${validation?.status || 'unknown'}".`);

package/lib/role-assistant/evidence-validation-issues.js

@@ -0,0 +1,51 @@
+/**
+ * Format Evidence validate issues[] for CLI errors.
+ */
+
+'use strict';
+
+function formatOneEvidenceIssue(issue) {
+  if (issue === undefined || issue === null) {
+    return '';
+  }
+  if (typeof issue !== 'object') {
+    return String(issue);
+  }
+  const bits = [];
+  if (issue.field) {
+    bits.push(String(issue.field));
+  }
+  if (issue.code) {
+    bits.push(String(issue.code));
+  }
+  if (issue.message) {
+    bits.push(String(issue.message));
+  }
+  if (bits.length > 0) {
+    return bits.join(' — ');
+  }
+  try {
+    return JSON.stringify(issue);
+  } catch {
+    return String(issue);
+  }
+}
+
+/**
+ * @param {unknown} issues
+ * @returns {string}
+ */
+function formatEvidenceValidationIssues(issues) {
+  if (!Array.isArray(issues) || issues.length === 0) {
+    return '0 issues';
+  }
+  const parts = issues.map(formatOneEvidenceIssue).filter(Boolean);
+  const noun = issues.length === 1 ? 'issue' : 'issues';
+  const detail = parts.length > 0 ? `: ${parts.join('; ')}` : '';
+  return `${issues.length} ${noun}${detail}`;
+}
+
+module.exports = {
+  formatOneEvidenceIssue,
+  formatEvidenceValidationIssues
+};

package/lib/role-assistant/knowledge-sync.js

@@ -19,6 +19,7 @@ const {
   updateAssistantSettings
 } = require('../api/assistants.api');
 const { resolveExternalSystemPath } = require('../utils/app-path-resolve');
+const { bareRoleKey } = require('../utils/role-assistant-paths');
 const {
   SYSTEM_KIND_DIGITAL_WORKER,
   getRoleAssistantYamlPath,
@@ -75,7 +76,11 @@ async function resolveDocumentStorageKeyFromDataplane(dataplaneUrl, authConfig,
     return null;
   }
   try {
-    const response = await getAssistantDetails(dataplaneUrl, systemKey, authConfig);
+    const response = await getAssistantDetails(
+      dataplaneUrl,
+      systemKey,
+      authConfig
+    );
     return extractDocumentStorageKeyFromAssistantDetails(response);
   } catch (_error) {
     return null;
@@ -141,16 +146,17 @@ async function applyAssistantSettingsPush(dataplaneUrl, systemKey, authConfig, s
   const { documentStorageKey, debugBody, patchBody } = settingsPush;
   const hasDocumentStorageKey = documentStorageKey !== '';
   const hasDebugSettings = Object.keys(debugBody).length > 0;
+  const assistantKey = String(systemKey || '').trim();
   let response = await updateAssistantSettings(
     dataplaneUrl,
-    systemKey,
+    assistantKey,
     authConfig,
     patchBody
   );
   if (response && response.success === false && hasDocumentStorageKey && hasDebugSettings) {
     response = await updateAssistantSettings(
       dataplaneUrl,
-      systemKey,
+      assistantKey,
       authConfig,
       debugBody
     );
@@ -352,7 +358,7 @@ function writeRoleAssistantSettingsFile(systemKey, docStorageKey, environment =
     apiVersion: 'aifabrix.ai/v1',
     version: '1.0.0',
     kind: 'RoleAssistantSettings',
-    roleKey: systemKey,
+    roleKey: bareRoleKey(systemKey),
     [envKey]: {
       knowledge: docStorageKey ? { documentStorageKey: docStorageKey } : {}
     }

package/lib/role-assistant/package-validate.js

@@ -0,0 +1,175 @@
+/**
+ * Role Assistant package folder validation (settings, tests, evidence, knowledge).
+ * @fileoverview Walk ra-* governed files. Ignore leftover Connected System artifacts.
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('../internal/fs-real-sync');
+const { validateExternalFile, parseJsonFileContent } = require('../validation/validate-external-file');
+const { listTestCaseFiles } = require('./test-cases');
+const { validateTestCaseFile } = require('./test-case-validate');
+
+const SETTINGS_TYPE = 'role-assistant-settings';
+const EMPTY_TESTS_SKIP = 'tests/: skipped (no test cases)';
+
+function fileRow(filePath, type, result) {
+  return {
+    file: path.basename(filePath),
+    type,
+    valid: result.valid,
+    path: filePath,
+    errors: result.errors || [],
+    warnings: result.warnings || []
+  };
+}
+
+function listFilesByExt(dirPath, ext, acc) {
+  if (!fs.existsSync(dirPath)) {
+    return acc;
+  }
+  for (const name of fs.readdirSync(dirPath)) {
+    if (String(name).startsWith('.')) {
+      continue;
+    }
+    const full = path.join(dirPath, name);
+    const st = fs.statSync(full);
+    if (st.isDirectory()) {
+      listFilesByExt(full, ext, acc);
+    } else if (String(name).toLowerCase().endsWith(ext)) {
+      acc.push(full);
+    }
+  }
+  return acc;
+}
+
+function evidenceRows(parsed) {
+  if (Array.isArray(parsed)) {
+    return parsed;
+  }
+  if (parsed && typeof parsed === 'object') {
+    return [parsed];
+  }
+  return null;
+}
+
+function validateEvidenceJsonFile(filePath) {
+  const parseResult = parseJsonFileContent(filePath);
+  if (parseResult.error) {
+    return { ...parseResult.error, file: filePath, type: 'evidence' };
+  }
+  const rows = evidenceRows(parseResult.parsed);
+  const errors = [];
+  if (!rows) {
+    errors.push(`${filePath}: Evidence JSON must be an object or array of objects`);
+  } else {
+    rows.forEach((row, index) => {
+      const key = row && typeof row === 'object' && !Array.isArray(row) ? String(row.key || '').trim() : '';
+      if (!key) {
+        errors.push(`${filePath}: item ${index} is missing key`);
+      }
+    });
+  }
+  return { valid: errors.length === 0, errors, warnings: [], file: filePath, type: 'evidence' };
+}
+
+function validateKnowledgeMarkdown(filePath) {
+  const text = fs.readFileSync(filePath, 'utf8');
+  if (!String(text).trim()) {
+    return {
+      valid: false,
+      errors: [`${filePath}: knowledge markdown must not be empty`],
+      warnings: [],
+      file: filePath,
+      type: 'knowledge'
+    };
+  }
+  return { valid: true, errors: [], warnings: [], file: filePath, type: 'knowledge' };
+}
+
+async function validateSettingsFile(appPath) {
+  const yamlPath = path.join(appPath, 'role-assistant.yaml');
+  try {
+    const result = await validateExternalFile(yamlPath, SETTINGS_TYPE);
+    return fileRow(yamlPath, SETTINGS_TYPE, result);
+  } catch (error) {
+    return fileRow(yamlPath, SETTINGS_TYPE, {
+      valid: false,
+      errors: [error.message],
+      warnings: []
+    });
+  }
+}
+
+function collectDuplicateCaseIdErrors(caseFiles) {
+  const seen = new Map();
+  const errors = [];
+  for (const row of caseFiles) {
+    const parseResult = parseJsonFileContent(row.path);
+    const caseId = parseResult.parsed && String(parseResult.parsed.caseId || '').trim();
+    if (!caseId) {
+      continue;
+    }
+    if (seen.has(caseId)) {
+      errors.push(`${row.path}: duplicate caseId "${caseId}" (also ${seen.get(caseId)})`);
+    } else {
+      seen.set(caseId, row.path);
+    }
+  }
+  return errors;
+}
+
+function validateTestFiles(appPath) {
+  const testsDir = path.join(appPath, 'tests');
+  const yamlFiles = listTestCaseFiles(testsDir);
+  if (yamlFiles.length === 0) {
+    return { files: [], errors: [], warnings: [EMPTY_TESTS_SKIP] };
+  }
+  const files = yamlFiles.map((filePath) => fileRow(filePath, 'role-assistant-test-case', validateTestCaseFile(filePath)));
+  const errors = files.flatMap((row) => row.errors);
+  errors.push(...collectDuplicateCaseIdErrors(files));
+  return { files, errors, warnings: [] };
+}
+
+function validateEvidenceFiles(appPath) {
+  const jsonFiles = listFilesByExt(path.join(appPath, 'evidence'), '.json', []);
+  const files = jsonFiles.map((filePath) => fileRow(filePath, 'evidence', validateEvidenceJsonFile(filePath)));
+  return { files, errors: files.flatMap((row) => row.errors), warnings: [] };
+}
+
+function validateKnowledgeFiles(appPath) {
+  const mdFiles = listFilesByExt(path.join(appPath, 'knowledge'), '.md', []).filter((filePath) => {
+    return path.dirname(filePath) === path.join(appPath, 'knowledge');
+  });
+  const files = mdFiles.map((filePath) => fileRow(filePath, 'knowledge', validateKnowledgeMarkdown(filePath)));
+  return { files, errors: files.flatMap((row) => row.errors), warnings: [] };
+}
+
+async function validateRoleAssistantPackage(appPath) {
+  const settings = await validateSettingsFile(appPath);
+  const tests = validateTestFiles(appPath);
+  const evidence = validateEvidenceFiles(appPath);
+  const knowledge = validateKnowledgeFiles(appPath);
+  const files = [settings, ...tests.files, ...evidence.files, ...knowledge.files];
+  const errors = [
+    ...settings.errors,
+    ...tests.errors,
+    ...evidence.errors,
+    ...knowledge.errors
+  ];
+  const warnings = [...settings.warnings, ...tests.warnings, ...evidence.warnings, ...knowledge.warnings];
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    files
+  };
+}
+
+module.exports = {
+  EMPTY_TESTS_SKIP,
+  validateRoleAssistantPackage,
+  validateEvidenceJsonFile,
+  validateKnowledgeMarkdown
+};