@aifabrix/builder 2.53.1 → 2.55.0

package/lib/commands/repair-rbac-platform-preset.js

@@ -1,5 +1,5 @@
 /**
- * Platform RBAC preset for orchestration facade external systems (plan 154.7).
+ * Platform RBAC preset for orchestration facade external systems.
  *
  * @fileoverview Replace per-system admin/reader with dataplane platform roles
  * @author AI Fabrix Team
@@ -13,29 +13,40 @@ const fs = require('fs');
 const { loadConfigFile, writeConfigFile } = require('../utils/config-format');
 const { backupIntegrationFile } = require('../utils/integration-file-backup');
 const { CAPABILITIES } = require('../programmatic/capability-registry');
-const { listPlatformRoles, PLATFORM_ROLE_VALUES } = require('../programmatic/platform-rbac-catalog');
+const {
+  listPlatformRoles,
+  PLATFORM_ROLE_VALUES,
+  ROLE_OBSERVER,
+  ROLE_EXTERNAL_SYSTEM_DISCOVERER,
+  ROLE_DEVELOPER,
+  ROLE_DEPLOYMENT_ADMIN,
+  ROLE_PLATFORM_ADMIN,
+  ROLE_SECURITY_ADMIN,
+  ROLE_COMPLIANCE_ADMIN,
+  ROLE_AI_TRUST_OPERATOR
+} = require('../programmatic/platform-rbac-catalog');
 
 const READ_ROLES = Object.freeze([
-  'aifabrix-observer',
-  'aifabrix-external-system-discoverer',
-  'aifabrix-developer',
-  'aifabrix-deployment-admin',
-  'aifabrix-platform-admin'
+  ROLE_OBSERVER,
+  ROLE_EXTERNAL_SYSTEM_DISCOVERER,
+  ROLE_DEVELOPER,
+  ROLE_DEPLOYMENT_ADMIN,
+  ROLE_PLATFORM_ADMIN
 ]);
 
 const WRITE_ROLES = Object.freeze([
-  'aifabrix-developer',
-  'aifabrix-deployment-admin',
-  'aifabrix-platform-admin'
+  ROLE_DEVELOPER,
+  ROLE_DEPLOYMENT_ADMIN,
+  ROLE_PLATFORM_ADMIN
 ]);
 
-const APPLY_ROLES = Object.freeze(['aifabrix-deployment-admin', 'aifabrix-platform-admin']);
+const APPLY_ROLES = Object.freeze([ROLE_DEPLOYMENT_ADMIN, ROLE_PLATFORM_ADMIN]);
 
 const CERTIFY_ROLES = Object.freeze([
-  'aifabrix-security-admin',
-  'aifabrix-compliance-admin',
-  'aifabrix-ai-trust-operator',
-  'aifabrix-platform-admin'
+  ROLE_SECURITY_ADMIN,
+  ROLE_COMPLIANCE_ADMIN,
+  ROLE_AI_TRUST_OPERATOR,
+  ROLE_PLATFORM_ADMIN
 ]);
 
 /** @type {ReadonlyMap<string, string>} */

package/lib/commands/repair-rbac-reader-roles.js

@@ -11,6 +11,10 @@
 const fs = require('fs');
 const path = require('path');
 const { loadConfigFile } = require('../utils/config-format');
+const {
+  pickCatalogAdminRoleValue,
+  pickCatalogReaderRoleValue
+} = require('./repair-rbac-catalog-defaults');
 
 const READ_ONLY_HTTP_METHODS = new Set(['GET', 'HEAD']);
 
@@ -19,23 +23,6 @@ function roleValues(rbac) {
   return roles.map((r) => r?.value).filter((v) => typeof v === 'string' && v.trim());
 }
 
-function pickAdminRoleValue(roleValuesList, systemKey) {
-  return (
-    roleValuesList.find((v) => v === `${systemKey}-admin`) ||
-    roleValuesList.find((v) => /-admin$/.test(v)) ||
-    roleValuesList[0] ||
-    null
-  );
-}
-
-function pickReaderRoleValue(roleValuesList, systemKey) {
-  return (
-    roleValuesList.find((v) => v === `${systemKey}-reader`) ||
-    roleValuesList.find((v) => /-reader$/.test(v)) ||
-    null
-  );
-}
-
 function capabilityFromPermissionName(name) {
   if (typeof name !== 'string' || !name.includes(':')) return null;
   return name.split(':')[1] || null;
@@ -71,8 +58,8 @@ function ensureNonEmptyPermissionRoles(rbac, systemKey, changes) {
   const values = roleValues(rbac);
   if (!Array.isArray(rbac.permissions) || values.length === 0) return false;
 
-  const adminValue = pickAdminRoleValue(values, systemKey);
-  const readerValue = pickReaderRoleValue(values, systemKey);
+  const adminValue = pickCatalogAdminRoleValue(values, systemKey);
+  const readerValue = pickCatalogReaderRoleValue(values, systemKey);
   let updated = false;
 
   for (const perm of rbac.permissions) {
@@ -103,8 +90,8 @@ function ensureNonEmptyPermissionRoles(rbac, systemKey, changes) {
  */
 function ensureReaderRoleOnReadPermissions(rbac, appPath, datasourceFiles, systemKey, changes) {
   const values = roleValues(rbac);
-  const readerValue = pickReaderRoleValue(values, systemKey);
-  const adminValue = pickAdminRoleValue(values, systemKey);
+  const readerValue = pickCatalogReaderRoleValue(values, systemKey);
+  const adminValue = pickCatalogAdminRoleValue(values, systemKey);
   if (!readerValue || !adminValue) return false;
   if (!Array.isArray(rbac.permissions) || rbac.permissions.length === 0) return false;
 

package/lib/commands/repair-rbac.js

@@ -29,6 +29,8 @@ const {
   ensureOrchestrationResourceType
 } = require('./repair-rbac-platform-preset');
 const { trackRepairWrite } = require('./repair-changed-files');
+const { listCapabilityKeys } = require('../datasource/capability/capability-manifest');
+const { ensureDefaultRoles } = require('./repair-rbac-catalog-defaults');
 
 const DEFAULT_CAPABILITIES = ['list', 'get', 'create', 'update', 'delete'];
 
@@ -46,24 +48,29 @@ function _normalizeOperationKey(opKey) {
   return cleaned.replace(/-+/g, '-').replace(/^-+|-+$/g, '');
 }
 
+function defaultCapabilitiesForDatasource(parsed) {
+  if (String(parsed?.storageType || '') === 'view') {
+    return ['list', 'get'];
+  }
+  return [...DEFAULT_CAPABILITIES];
+}
+
 /**
- * Resolves capabilities from datasource (array or legacy object).
+ * Resolves capabilities from datasource (array, COM objects, or legacy map).
  * @param {Object} parsed - Parsed datasource
  * @returns {string[]}
  */
 function getCapabilitiesFromDatasource(parsed) {
-  const cap = parsed?.capabilities;
-  if (Array.isArray(cap)) {
-    const arr = cap.filter(c => typeof c === 'string');
-    if (arr.length > 0) return arr;
-    return [...DEFAULT_CAPABILITIES];
+  const fromList = listCapabilityKeys(parsed?.capabilities);
+  if (fromList.length > 0) {
+    return fromList;
   }
-  if (cap && typeof cap === 'object') {
-    const keys = Object.keys(cap).filter(k => cap[k] === true);
+  const cap = parsed?.capabilities;
+  if (cap && typeof cap === 'object' && !Array.isArray(cap)) {
+    const keys = Object.keys(cap).filter((k) => cap[k] === true);
     if (keys.length > 0) return keys;
-    return [...DEFAULT_CAPABILITIES];
   }
-  return [...DEFAULT_CAPABILITIES];
+  return defaultCapabilitiesForDatasource(parsed);
 }
 
 /**
@@ -269,48 +276,23 @@ function addMissingPermissions(rbac, permissionNames, changes) {
   return updated;
 }
 
-/**
- * Ensures default Admin and Reader roles if rbac.roles is empty. Mutates rbac.
- * @param {Object} rbac - RBAC object (mutated)
- * @param {string} systemKey - System key
- * @param {string} displayName - Display name
- * @param {string[]} changes - Array to append to
- * @returns {boolean}
- */
-function ensureDefaultRoles(rbac, systemKey, displayName, changes) {
-  const hasRoles = Array.isArray(rbac.roles) && rbac.roles.length > 0;
-  if (hasRoles) return false;
-  const adminValue = `${systemKey}-admin`;
-  const readerValue = `${systemKey}-reader`;
-  rbac.roles = [
-    { name: `${displayName} Admin`, value: adminValue, description: `Full access to all ${displayName} operations`, groups: [] },
-    { name: `${displayName} Reader`, value: readerValue, description: `Read-only access to all ${displayName} data`, groups: [] }
-  ];
-  const listGetPerms = (rbac.permissions || [])
-    .filter(p => p?.name && (p.name.split(':')[1] === 'list' || p.name.split(':')[1] === 'get'))
-    .map(p => p.name);
-  for (const p of rbac.permissions || []) {
-    if (!p.roles) p.roles = [];
-    if (p.name && listGetPerms.includes(p.name) && !p.roles.includes(readerValue)) p.roles.push(readerValue);
-    if (!p.roles.includes(adminValue)) p.roles.push(adminValue);
-  }
-  changes.push('Added default Admin and Reader roles to rbac file');
-  return true;
-}
-
 /**
  * @param {Object} opts
  * @returns {boolean}
  */
 function applyRbacPresetRoles(opts) {
-  const { rbac, rbacPreset, systemKey, displayName, appPath, datasourceFiles, changes } = opts;
+  const { rbac, rbacPreset, appPath, datasourceFiles, changes } = opts;
   if (rbacPreset === 'platform') {
-    return (
-      ensurePlatformRolesOnRbac(rbac, changes) ||
-      applyPlatformRolesToPermissions(rbac, appPath, datasourceFiles, changes)
+    const rolesUpdated = ensurePlatformRolesOnRbac(rbac, changes);
+    const permsUpdated = applyPlatformRolesToPermissions(
+      rbac,
+      appPath,
+      datasourceFiles,
+      changes
     );
+    return rolesUpdated || permsUpdated;
   }
-  return ensureDefaultRoles(rbac, systemKey, displayName, changes);
+  return ensureDefaultRoles(rbac, changes);
 }
 
 /**

package/lib/commands/repair-system-permissions.js

@@ -9,6 +9,11 @@
 const path = require('path');
 const fs = require('fs');
 const { loadConfigFile } = require('../utils/config-format');
+const {
+  catalogAdminReaderRoles,
+  pickCatalogAdminRoleValue,
+  pickCatalogReaderRoleValue
+} = require('./repair-rbac-catalog-defaults');
 
 function _safeString(v) {
   return typeof v === 'string' && v.trim() ? v.trim() : '';
@@ -23,32 +28,29 @@ function _normalizeOperationKey(opKey) {
   return cleaned.replace(/-+/g, '-').replace(/^-+|-+$/g, '');
 }
 
-function _ensureDefaultRoles(systemParsed, systemKey) {
+function _roleValuesFromSystem(systemParsed) {
+  const roles = Array.isArray(systemParsed.roles) ? systemParsed.roles : [];
+  return roles
+    .map((r) => (r && typeof r === 'object' ? _safeString(r.value) : ''))
+    .filter(Boolean);
+}
+
+function _ensureDefaultRoles(systemParsed) {
   if (Array.isArray(systemParsed.roles) && systemParsed.roles.length > 0) return false;
-  const key = _safeString(systemKey) || _safeString(systemParsed?.key) || 'system';
-  const display = _safeString(systemParsed?.displayName) || key;
-  systemParsed.roles = [
-    {
-      name: `${display} Admin`,
-      value: `${key}-admin`,
-      description: `Full access to all ${display} operations`,
-      groups: []
-    },
-    {
-      name: `${display} Reader`,
-      value: `${key}-reader`,
-      description: `Read-only access to all ${display} data`,
-      groups: []
-    }
-  ];
+  const seeded = catalogAdminReaderRoles();
+  if (seeded.length < 2) return false;
+  systemParsed.roles = seeded;
   return true;
 }
 
 function _pickRoleValue(systemParsed, suffix, fallback) {
-  const roles = Array.isArray(systemParsed.roles) ? systemParsed.roles : [];
-  const vals = roles
-    .map((r) => r && typeof r === 'object' ? _safeString(r.value) : '')
-    .filter(Boolean);
+  const vals = _roleValuesFromSystem(systemParsed);
+  if (suffix === '-admin') {
+    return pickCatalogAdminRoleValue(vals, undefined, fallback);
+  }
+  if (suffix === '-reader') {
+    return pickCatalogReaderRoleValue(vals, undefined, vals[0] || fallback);
+  }
   return vals.find((v) => v.endsWith(suffix)) || vals[0] || fallback;
 }
 
@@ -145,7 +147,7 @@ function ensureSystemPermissionsForAutoRbac(appPath, systemParsed, datasourceFil
   const desired = _collectAutoRbacOperationPermissions(appPath, datasourceFiles);
   if (desired.size === 0) return false;
 
-  const rolesAdded = _ensureDefaultRoles(systemParsed, systemParsed?.key);
+  const rolesAdded = _ensureDefaultRoles(systemParsed);
   if (rolesAdded) {
     changes.push('Added default Admin/Reader roles (required for RBAC permissions)');
   }

package/lib/commands/role-assistant-copy-output.js

@@ -0,0 +1,61 @@
+/**
+ * TTY and --json output for role-assistant copy.
+ *
+ * @fileoverview Success and blocking copy envelopes
+ */
+
+'use strict';
+
+const logger = require('../utils/logger');
+const { formatSuccessLine, formatBlockingError } = require('../utils/cli-layout-chalk');
+
+function copyWarnings(result) {
+  return Array.isArray(result.warnings) ? result.warnings : [];
+}
+
+function buildCopyEnvelope(result) {
+  const envelope = {
+    success: true,
+    path: result.path,
+    caseId: result.caseId,
+    suiteId: result.suiteId,
+    processExecutionId: result.processExecutionId
+  };
+  const warnings = copyWarnings(result);
+  if (warnings.length > 0) {
+    envelope.warnings = warnings;
+  }
+  if (result.dryRun === true) {
+    envelope.dryRun = true;
+    envelope.yaml = result.yaml;
+  }
+  return envelope;
+}
+
+function emitCopySuccess(options, result) {
+  if (options && options.json) {
+    logger.log(JSON.stringify(buildCopyEnvelope(result), null, 2));
+    return;
+  }
+  if (result.dryRun === true) {
+    logger.log(result.yaml);
+    logger.log(formatSuccessLine(`Would write ${result.path}`));
+    return;
+  }
+  logger.log(formatSuccessLine(`Wrote ${result.path}`));
+}
+
+function emitCopyFailure(options, error) {
+  const message = error && error.message ? error.message : String(error);
+  if (options && options.json) {
+    logger.log(JSON.stringify({ success: false, error: message }));
+    return;
+  }
+  logger.error(formatBlockingError(message));
+}
+
+module.exports = {
+  buildCopyEnvelope,
+  emitCopySuccess,
+  emitCopyFailure
+};

package/lib/commands/role-assistant-copy.js

@@ -0,0 +1,155 @@
+/**
+ * aifabrix role-assistant copy — capture one Work Hub execution as YAML.
+ *
+ * @fileoverview Leaf command; Builder materializes the case from Work Hub reference
+ */
+
+'use strict';
+
+const { resolveLifecycleAuth } = require('./lifecycle-external');
+const { fetchWorkCopyReference, buildCopyCaseFromWorkReference } = require(
+  '../role-assistant/test-case-copy-from-work'
+);
+const { roleAssistantSystemKey } = require('../utils/role-assistant-paths');
+const { roleAssistantTestsDir } = require('../role-assistant/test-cases');
+const {
+  defaultCaseIdFromReference,
+  assertProcessExecutionId,
+  assertFolderToken,
+  copyTargetPath,
+  prepareCopyDocument,
+  yamlFromValidatedCase,
+  assertCopyTargetWritable,
+  persistCopyCaseYaml
+} = require('../role-assistant/test-case-copy');
+const { emitCopySuccess, emitCopyFailure } = require('./role-assistant-copy-output');
+
+function copyHelpAfter() {
+  return `
+Examples:
+  $ aifabrix role-assistant copy customer-support-bot --suite 001 --reference a9f09fb8-d9eb-477f-8bb4-59e670fc82a4
+  $ aifabrix role-assistant copy customer-support-bot --suite 001 --reference a9f09fb8-d9eb-477f-8bb4-59e670fc82a4 --case address-change
+  $ aifabrix role-assistant copy customer-support-bot --suite 001 --reference a9f09fb8-d9eb-477f-8bb4-59e670fc82a4 --dry-run
+  $ aifabrix role-assistant copy customer-support-bot --suite 001 --reference a9f09fb8-d9eb-477f-8bb4-59e670fc82a4 --json
+
+Notes:
+  - <roleKey> is bare; package folder is role-assistant/ra-<roleKey>/.
+  - --reference is the Work Hub execution id (the same id printed after a run).
+  - Writes tests/<suite>/<caseId>.yaml. Default caseId is copy-<first 8 hex of the execution id>.
+  - Existing files are not overwritten unless --force is set.
+  - --dry-run prints YAML and does not write.
+  - Builds local YAML from Work Hub execution status and result. Does not publish; use upload / deploy.
+`;
+}
+
+function normalizeCopyOptions(options) {
+  const opts = options && typeof options === 'object' ? options : {};
+  return {
+    env: opts.env || 'dev',
+    suite: opts.suite,
+    reference: opts.reference,
+    case: opts.case,
+    force: opts.force === true,
+    dryRun: opts.dryRun === true,
+    json: opts.json === true,
+    testsDir: opts.testsDir || null
+  };
+}
+
+function requireCopyFlags(opts) {
+  if (!opts.suite) {
+    throw new Error('--suite is required');
+  }
+  if (!opts.reference) {
+    throw new Error('--reference is required');
+  }
+}
+
+async function fetchCopyCase(systemKey, opts, peId, caseId) {
+  const auth = await resolveLifecycleAuth(systemKey, {
+    env: opts.env,
+    run: false,
+    noPublish: true
+  });
+  if (!auth || !auth.dataplaneUrl || !auth.authConfig) {
+    throw new Error('Not authenticated. Run aifabrix login, then retry.');
+  }
+  const reference = await fetchWorkCopyReference(
+    auth.dataplaneUrl,
+    auth.authConfig,
+    peId
+  );
+  return buildCopyCaseFromWorkReference({
+    systemKey,
+    caseId,
+    processExecutionId: peId,
+    status: reference.status,
+    result: reference.result
+  });
+}
+
+async function runRoleAssistantCopy(roleKey, options) {
+  const opts = normalizeCopyOptions(options);
+  requireCopyFlags(opts);
+  const peId = assertProcessExecutionId(opts.reference);
+  const suiteId = assertFolderToken(opts.suite, 'Suite id');
+  const caseId = assertFolderToken(
+    opts.case || defaultCaseIdFromReference(peId),
+    'Case id'
+  );
+  const systemKey = roleAssistantSystemKey(roleKey);
+  const testsDir = roleAssistantTestsDir(systemKey, { testsDir: opts.testsDir });
+  const targetPath = copyTargetPath(testsDir, suiteId, caseId);
+  if (!opts.dryRun) {
+    assertCopyTargetWritable(targetPath, opts.force);
+  }
+  const payload = await fetchCopyCase(systemKey, opts, peId, caseId);
+  const caseDoc = prepareCopyDocument(payload, caseId, peId);
+  const yamlText = yamlFromValidatedCase(caseDoc);
+  if (!opts.dryRun) {
+    persistCopyCaseYaml(targetPath, yamlText);
+  }
+  return {
+    success: true,
+    path: targetPath,
+    caseId,
+    suiteId,
+    processExecutionId: peId,
+    warnings: payload && payload.warnings,
+    yaml: yamlText,
+    dryRun: opts.dryRun
+  };
+}
+
+async function roleAssistantCopyHandler(roleKey, options) {
+  try {
+    const result = await runRoleAssistantCopy(roleKey, options);
+    emitCopySuccess(options, result);
+  } catch (error) {
+    emitCopyFailure(options, error);
+    process.exit(error && error.exitCode ? error.exitCode : 1);
+  }
+}
+
+function registerRoleAssistantCopyCommand(roleAssistant) {
+  roleAssistant
+    .command('copy <roleKey>')
+    .description('Capture one Work Hub execution as a local YAML test case')
+    .requiredOption('--suite <suiteId>', 'Suite folder under tests/ (for example 001)')
+    .requiredOption('--reference <executionId>', 'Work Hub execution id')
+    .option('--case <caseId>', 'Case id (default: copy-<first 8 hex of the execution id>)')
+    .option('--force', 'Overwrite an existing YAML file')
+    .option('--dry-run', 'Print YAML and do not write')
+    .option('-e, --env <env>', 'Environment: dev, tst, or pro', 'dev')
+    .option('--json', 'Machine-readable output envelope')
+    .addHelpText('after', copyHelpAfter())
+    .action((roleKey, options) => roleAssistantCopyHandler(roleKey, options));
+}
+
+module.exports = {
+  copyHelpAfter,
+  normalizeCopyOptions,
+  runRoleAssistantCopy,
+  roleAssistantCopyHandler,
+  registerRoleAssistantCopyCommand
+};

package/lib/commands/role-assistant-test-output.js

@@ -16,6 +16,7 @@ const {
   formatBlockingError,
   metadata
 } = require('../utils/cli-test-layout-chalk');
+const { formatCaseResultRows } = require('./role-assistant-test-result-rows');
 
 /**
  * Bucket a lifecycle step status into ok | failed | skipped | other.
@@ -81,6 +82,19 @@ function mapCaseEnvelopeRow(row) {
   };
 }
 
+function attachEnvelopeIsolation(envelope, opts) {
+  const emails = Array.isArray(opts.subjectEmail)
+    ? opts.subjectEmail.map((value) => String(value || '').trim()).filter(Boolean)
+    : [];
+  const userIds = Array.isArray(opts.subjectUserId)
+    ? opts.subjectUserId.map((value) => String(value || '').trim()).filter(Boolean)
+    : [];
+  if (emails.length === 0 && userIds.length === 0) {
+    return;
+  }
+  envelope.isolation = { subjectEmails: emails, subjectUserIds: userIds };
+}
+
 function attachEnvelopeCases(envelope, caseResult) {
   if (Array.isArray(caseResult)) {
     envelope.cases = caseResult.map(mapCaseEnvelopeRow);
@@ -118,6 +132,7 @@ function buildRoleAssistantTestEnvelope(roleKey, verdict, portalUrl, result, opt
     summary: null
   };
   attachEnvelopeCases(envelope, caseResult);
+  attachEnvelopeIsolation(envelope, opts);
   if (opts.verbose || opts.debug) {
     envelope.report = report;
   }
@@ -143,15 +158,12 @@ function displayCaseResultSummary(caseResult) {
   }
   if (caseResult.passed) {
     logger.log(formatSuccessLine('Case assertions passed.'));
-    const warnings = Array.isArray(caseResult.warnings) ? caseResult.warnings : [];
-    for (const row of warnings) {
-      logger.log(formatWarningLine(row.message || String(row)));
-    }
-    return;
+  } else {
+    logger.log(formatBlockingError('Case assertions failed.'));
   }
-  logger.log(formatBlockingError('Case assertions failed.'));
-  for (const row of caseResult.failedAssertions) {
-    logger.log(formatWarningLine(row.message));
+  logger.log(metadata('Results:'));
+  for (const line of formatCaseResultRows(caseResult.assertions)) {
+    logger.log(line);
   }
 }
 
@@ -196,5 +208,6 @@ function displayRoleAssistantTestSummary(roleKey, verdict, portalUrl, result, ca
 module.exports = {
   formatStepsRunSummary,
   buildRoleAssistantTestEnvelope,
-  displayRoleAssistantTestSummary
+  displayRoleAssistantTestSummary,
+  formatCaseResultRows
 };

package/lib/commands/role-assistant-test-result-rows.js

@@ -0,0 +1,42 @@
+/**
+ * Human TTY lines for Role Assistant case assertion rows.
+ * @fileoverview Canonical glyphs for pass/fail/warn/notes/skip
+ */
+
+'use strict';
+
+const {
+  formatSuccessLine,
+  formatWarningLine,
+  formatBlockingError,
+  infoLine,
+  metadata
+} = require('../utils/cli-test-layout-chalk');
+const { withKind } = require('../role-assistant/test-case-assertion-row');
+
+function formatCaseResultLine(assertion) {
+  const row = withKind(assertion || {});
+  const text = `${row.id || 'assertion'} — ${row.message || ''}`.trim();
+  if (row.kind === 'fail') {
+    return `  ${formatBlockingError(text)}`;
+  }
+  if (row.kind === 'warn') {
+    return `  ${formatWarningLine(text)}`;
+  }
+  if (row.kind === 'notes') {
+    return `  ${infoLine(`ℹ ${text}`)}`;
+  }
+  if (row.kind === 'skip') {
+    return `  ${metadata(`⏭ ${text}`)}`;
+  }
+  return `  ${formatSuccessLine(text)}`;
+}
+
+function formatCaseResultRows(assertions) {
+  return (Array.isArray(assertions) ? assertions : []).map(formatCaseResultLine);
+}
+
+module.exports = {
+  formatCaseResultLine,
+  formatCaseResultRows
+};