@aifabrix/builder 2.54.1 → 2.55.0

package/lib/commands/agent-kit.js

@@ -0,0 +1,346 @@
+/**
+ * `aifabrix agent-kit` command group.
+ * @fileoverview Install, init, status, update, validate, remote create
+ */
+
+'use strict';
+
+const logger = require('../utils/logger');
+const { handleCommandError } = require('../utils/cli-utils');
+const { formatSuccessLine, formatBlockingError, formatWarningLine } = require('../utils/cli-layout-chalk');
+const { runInstall, runUpdate } = require('../agent-kit/run');
+const path = require('path');
+const { runInit, runRemoteCreate } = require('../agent-kit/init');
+const { enrichInitHostOptions, enrichInitRemoteOptions, enrichRemoteOptions, enrichApproveAllOptions } = require('../agent-kit/remote-prompts');
+const { hostLabel } = require('../agent-kit/hosts');
+const { runStatus } = require('../agent-kit/status');
+const { runValidate } = require('../agent-kit/validate-kit');
+const { formatHumanStatus } = require('../agent-kit/report');
+const { KIT_STATE } = require('../agent-kit/constants');
+const { loadState } = require('../agent-kit/state-file');
+const { resolveGitRoot } = require('../agent-kit/repo-guard');
+const {
+  GROUP_HELP,
+  INSTALL_HELP,
+  STATUS_HELP,
+  UPDATE_HELP,
+  VALIDATE_HELP,
+  INIT_HELP,
+  REMOTE_HELP
+} = require('./agent-kit-help');
+
+/**
+ * @param {object} json
+ * @param {boolean} asJson
+ * @returns {void}
+ */
+function emitReport(json, asJson) {
+  if (asJson) {
+    logger.log(JSON.stringify(json, null, 2));
+    return;
+  }
+  logger.log(formatHumanStatus(json));
+  if (json.conflicts && json.conflicts.length) {
+    logger.log(formatWarningLine(`Conflicts: ${json.conflicts.join(', ')}`));
+  }
+}
+
+/**
+ * @param {object} json
+ * @param {boolean} asJson
+ * @returns {void}
+ */
+function emitInitReport(json, asJson) {
+  if (asJson) {
+    logger.log(JSON.stringify(json, null, 2));
+    return;
+  }
+  logger.log('AI Fabrix workspace init');
+  logger.log(`Path       ${json.path}`);
+  logger.log(`Name       ${json.name}`);
+  logger.log(`SCM        ${json.scm}`);
+  if (json.hosts && json.hosts.length) {
+    logger.log(`Hosts      ${json.hosts.map((h) => hostLabel(h)).join(', ')}`);
+  }
+  if (json.kit) {
+    logger.log(`Agent Kit  ${json.kit.kitVersion} (${json.kit.state})`);
+  }
+  if (json.remote && !json.remote.skipped) {
+    logger.log(`Remote     ${json.remote.provider}:${json.remote.fullName} (${json.remote.visibility})`);
+  } else {
+    logger.log('Remote     skipped (use: aifabrix agent-kit remote create)');
+  }
+  logger.log(formatSuccessLine(json.dryRun ? 'Dry-run complete' : 'Done'));
+}
+
+/**
+ * @param {object} json
+ * @param {boolean} asJson
+ * @returns {void}
+ */
+function emitRemoteReport(json, asJson) {
+  if (asJson) {
+    logger.log(JSON.stringify(json, null, 2));
+    return;
+  }
+  if (json.remote && json.remote.skipped) {
+    logger.log(formatWarningLine(`Remote skipped: ${json.remote.reason || 'already configured'}`));
+  } else if (json.remote) {
+    logger.log(`Remote     ${json.remote.provider}:${json.remote.fullName} (${json.remote.visibility})`);
+  }
+  logger.log(formatSuccessLine(json.dryRun ? 'Dry-run complete' : 'Done'));
+}
+
+/**
+ * @param {Function} runner
+ * @param {object} options
+ * @param {boolean} [failOnConflict]
+ * @returns {Promise<void>}
+ */
+async function runLeaf(runner, options, failOnConflict) {
+  const json = runner(options);
+  emitReport(json, Boolean(options.json));
+  if (failOnConflict && json.conflicts && json.conflicts.length) {
+    logger.error(formatBlockingError('Managed files were modified locally. Re-run with --force to replace kit-owned content only.'));
+    process.exitCode = 1;
+    return;
+  }
+  if (!options.json && json.state && json.state !== KIT_STATE.NOT_INSTALLED) {
+    logger.log(formatSuccessLine(json.dryRun ? 'Dry-run complete' : 'Done'));
+  }
+}
+
+/**
+ * @param {import('commander').Command} program
+ */
+function setupAgentKitCommands(program) {
+  const group = program
+    .command('agent-kit')
+    .description('Install, init, and update the AI Fabrix Agent Kit in a customer workspace')
+    .addHelpText('after', GROUP_HELP);
+
+  addInitCommand(group);
+  addInstallCommand(group);
+  addStatusCommand(group);
+  addUpdateCommand(group);
+  addValidateCommand(group);
+  addRemoteCommand(group);
+}
+
+/**
+ * @param {import('commander').Command} group
+ */
+function addInitCommand(group) {
+  group
+    .command('init [nameOrPath]')
+    .description('Create a customer workspace skeleton, git repo, and Agent Kit')
+    .option('--host <target>', 'all, cursor, codex, or claude (omit on TTY to choose)', 'all')
+    .option('--scm <kind>', 'git or none', 'git')
+    .option('--remote', 'Create private hosting remote and push (requires auth)')
+    .option('--no-remote', 'Force local-only (skip remote prompt on TTY)')
+    .option('--org <owner>', 'Hosting org or user (required with --remote when non-TTY)')
+    .option('--visibility <mode>', 'private or public', 'private')
+    .option('--license <kind>', 'mit or none', 'none')
+    .option('--force', 'Allow non-empty target directory')
+    .option('--yes', 'Silent: skip TTY confirm (pair with --host and --org); also auto-approves host permissions')
+    .option('--approve-all', 'Write Claude Code and Codex auto-approve configs')
+    .option('--skip-approve-all', 'Do not write Claude Code or Codex auto-approve configs')
+    .option('--dry-run', 'Plan writes without changing files')
+    .option('--json', 'Machine-readable output')
+    .addHelpText('after', INIT_HELP)
+    .action(async(nameOrPath, options) => {
+      try {
+        const interactive = Boolean(process.stdout.isTTY) && !options.json;
+        const withHost = await enrichInitHostOptions(
+          { ...options, nameOrPath },
+          { interactive }
+        );
+        const withApprove = await enrichApproveAllOptions(withHost, { interactive });
+        const merged = await enrichInitRemoteOptions(withApprove, {
+          interactive,
+          workspaceName: path.basename(String(nameOrPath || 'workspace'))
+        });
+        if (merged.cancelled) {
+          logger.log('Cancelled.');
+          return;
+        }
+        const json = runInit(merged);
+        emitInitReport(json, Boolean(options.json));
+      } catch (error) {
+        handleCommandError(error, 'agent-kit init');
+        process.exitCode = 1;
+      }
+    });
+}
+
+/**
+ * @param {import('commander').Command} group
+ */
+function addRemoteCommand(group) {
+  const remote = group.command('remote').description('Hosting remotes for an Agent Kit workspace');
+  remote
+    .command('create')
+    .description('Create a private GitHub remote and push the current workspace')
+    .option('--org <owner>', 'Hosting org or user (required when non-TTY)')
+    .option('--name <repo>', 'Remote repository name (default: directory basename)')
+    .option('--visibility <mode>', 'private or public', 'private')
+    .option('--yes', 'Silent: skip TTY confirmation (pair with --org)')
+    .option('--dry-run', 'Plan without creating the remote')
+    .option('--json', 'Machine-readable output')
+    .addHelpText('after', REMOTE_HELP)
+    .action(async(options) => {
+      try {
+        const interactive = Boolean(process.stdout.isTTY) && !options.json;
+        const merged = await enrichRemoteOptions(options, {
+          interactive,
+          name: options.name || path.basename(process.cwd())
+        });
+        if (merged.cancelled) {
+          logger.log('Cancelled.');
+          return;
+        }
+        const json = runRemoteCreate(merged);
+        emitRemoteReport(json, Boolean(options.json));
+      } catch (error) {
+        handleCommandError(error, 'agent-kit remote create');
+        process.exitCode = 1;
+      }
+    });
+}
+
+/**
+ * @param {import('commander').Command} group
+ */
+function addInstallCommand(group) {
+  group
+    .command('install')
+    .description('Install the Agent Kit into the current git repository')
+    .option('--host <target>', 'all, cursor, codex, or claude', 'all')
+    .option('--approve-all', 'Write Claude Code and Codex auto-approve configs')
+    .option('--skip-approve-all', 'Do not write Claude Code or Codex auto-approve configs')
+    .option('--yes', 'Silent: auto-approve host permission configs without asking')
+    .option('--dry-run', 'Plan writes without changing files')
+    .option('--json', 'Machine-readable output')
+    .addHelpText('after', INSTALL_HELP)
+    .action(async(options) => {
+      try {
+        const interactive = Boolean(process.stdout.isTTY) && !options.json;
+        const merged = await enrichApproveAllOptions(options, { interactive });
+        await runLeaf(runInstall, merged, true);
+      } catch (error) {
+        handleCommandError(error, 'agent-kit install');
+        process.exitCode = 1;
+      }
+    });
+}
+
+/**
+ * @param {import('commander').Command} group
+ */
+function addStatusCommand(group) {
+  group
+    .command('status')
+    .description('Show installed Agent Kit version and file state')
+    .option('--json', 'Machine-readable output')
+    .addHelpText('after', STATUS_HELP)
+    .action(async(options) => {
+      try {
+        await runLeaf(runStatus, options, false);
+      } catch (error) {
+        handleCommandError(error, 'agent-kit status');
+        process.exitCode = 1;
+      }
+    });
+}
+
+/**
+ * Recorded --host from a previous install (update omits --host to keep this).
+ * @returns {string[]|undefined}
+ */
+function readRecordedHosts() {
+  try {
+    const state = loadState(resolveGitRoot(process.cwd()));
+    if (state && Array.isArray(state.hosts) && state.hosts.length) {
+      return state.hosts;
+    }
+  } catch {
+    return undefined;
+  }
+  return undefined;
+}
+
+/**
+ * Update does not prompt or auto-write host configs unless flags are set.
+ * @param {object} options
+ * @returns {Promise<object>}
+ */
+async function mergeUpdateApproveOptions(options) {
+  const interactive = Boolean(process.stdout.isTTY) && !options.json;
+  const host = options.host || readRecordedHosts();
+  return enrichApproveAllOptions({ ...options, host }, { interactive, ask: false });
+}
+
+/**
+ * @param {import('commander').Command} group
+ */
+function addUpdateCommand(group) {
+  group
+    .command('update')
+    .description('Update managed Agent Kit files from this Builder release')
+    .option('--host <target>', 'all, cursor, codex, or claude (omit to keep recorded hosts)')
+    .option('--approve-all', 'Write Claude Code and Codex auto-approve configs')
+    .option('--skip-approve-all', 'Do not write Claude Code or Codex auto-approve configs')
+    .option('--yes', 'Silent: auto-approve host permission configs without asking')
+    .option('--dry-run', 'Plan writes without changing files')
+    .option('--force', 'Replace modified kit-owned files and managed sections')
+    .option('--json', 'Machine-readable output')
+    .addHelpText('after', UPDATE_HELP)
+    .action(async(options) => {
+      try {
+        const merged = await mergeUpdateApproveOptions(options);
+        await runLeaf(runUpdate, merged, !options.force);
+      } catch (error) {
+        handleCommandError(error, 'agent-kit update');
+        process.exitCode = 1;
+      }
+    });
+}
+
+/**
+ * @param {import('commander').Command} group
+ */
+function addValidateCommand(group) {
+  group
+    .command('validate')
+    .description('Validate the bundled Agent Kit and the current repository install')
+    .option('--json', 'Machine-readable output')
+    .addHelpText('after', VALIDATE_HELP)
+    .action(async(options) => {
+      try {
+        await runValidateLeaf(options);
+      } catch (error) {
+        handleCommandError(error, 'agent-kit validate');
+        process.exitCode = 1;
+      }
+    });
+}
+
+/**
+ * @param {object} options
+ * @returns {Promise<void>}
+ */
+async function runValidateLeaf(options) {
+  const json = runValidate(options);
+  if (options.json) {
+    logger.log(JSON.stringify(json, null, 2));
+  } else if (json.success) {
+    logger.log(formatSuccessLine(`Agent Kit ${json.kitVersion} is valid`));
+  } else {
+    logger.error(formatBlockingError(json.errors.join('; ')));
+  }
+  if (!json.success) {
+    process.exitCode = 1;
+  }
+}
+
+module.exports = { setupAgentKitCommands };

package/lib/commands/channel-add-help.js

@@ -113,9 +113,9 @@ Behavior:
   - chatgpt registers the ChatGPT callback URL when provided (--callback-url or TTY prompt).
     It does not rotate the client secret. Remaining ChatGPT steps: Create with logo (cannot change later), Publish, Connect.
   - claude registers the Claude callback URL (https://claude.ai/api/mcp/auth_callback) and prints
-    Name and Server URL. Open https://claude.ai/new#settings/customize-connectors and add a
-    custom connector with those two values. Use channel configure claude --callback-url only if
-    Claude shows a callback that is not already registered.
+    Name, Server URL, and Authentication: OAuth. Open https://claude.ai/new#settings/customize-connectors
+    and add a custom connector with those three values (Runtime MCP requires sign-in). Use channel
+    configure claude --callback-url only if Claude shows a callback that is not already registered.
   - mcp-client writes the Runtime MCP URL into the editor MCP config. Pass --target (or --profile)
     with cursor, vscode, or github-copilot. It creates or reuses the Integration Client and never
     rotates the client secret. Remaining step: Reload the editor.
@@ -169,8 +169,8 @@ Examples:
 
 ${SHARED_TARGET_BEHAVIOR}
   - claude registers the Claude callback URL (https://claude.ai/api/mcp/auth_callback) and prints
-    Name and Server URL. Open https://claude.ai/new#settings/customize-connectors and add a
-    custom connector with those two values.
+    Name, Server URL, and Authentication: OAuth. Open https://claude.ai/new#settings/customize-connectors
+    and add a custom connector with those three values (Runtime MCP requires sign-in).
 
 Requires: aifabrix login
 

package/lib/commands/datasource-capability-relate-cli.js

@@ -18,9 +18,10 @@ const { runCapabilityRelate } = require('../datasource/capability/run-capability
 const { printCapabilitySuccessFooter } = require('./datasource-capability-output');
 
 const CAP_RELATE_HELP = `
-Adds or replaces one **foreignKeys[]** row (metadata-only; no pipeline). Optional **metadataSchema.properties** stub unless **--skip-metadata-property**.
+Adds or replaces one **foreignKeys[]** row (metadata-only; no pipeline). Optional **metadataSchema.properties** stub unless **--skip-metadata-property**. **--relation-name** defaults to the carrier **--field**.
 
-  $ aifabrix datasource capability relate hubspot-deals --relation-name company --to hubspot-companies --field companyId --target-field externalId
+  $ aifabrix datasource capability relate pkg-a-facts --to pkg-b-persons --field personId
+  $ aifabrix datasource capability relate pkg-a-facts --relation-name personId --to pkg-b-persons --field personId --target-field externalId
 `;
 
 function parseTargetFields(raw) {
@@ -103,8 +104,8 @@ function setupCapabilityRelateCommand(cap) {
     .description(
       'Add or replace foreignKeys[] metadata (+ optional metadataSchema property for relation name)'
     )
-    .requiredOption('--relation-name <name>', 'FK name (camelCase; unique per datasource)')
-    .requiredOption('--to <targetDatasource>', 'Target datasource key (cross-system JSON key)')
+    .option('--relation-name <name>', 'FK name (camelCase; defaults to --field)')
+    .requiredOption('--to <targetDatasource>', 'Target datasource key (sibling packages resolve by key)')
     .requiredOption('--field <name>', 'Local normalized attribute (foreignKeys.fields[])')
     .option('--description <text>', 'FK description (defaults to a generated description)')
     .option('--required', 'Mark FK required (foreignKeys[].required=true)')

package/lib/commands/repair-auth-apply.js

@@ -117,7 +117,7 @@ function repairAuthChangeLabel(authOption) {
 }
 
 const MISSING_TEST_ENDPOINT_WARNING =
-  'authentication.variables.testEndpoint is missing for apikey/bearerToken auth — add a GET URL for credential/E2E tests (e.g. /crm/v3/objects/contacts?limit=1, or a path resolved against baseUrl).';
+  'authentication.variables.testEndpoint is missing for apikey/bearerToken auth — add a GET URL for credential/E2E tests (use the OpenAPI minimum for required page-size query params, or a path resolved against baseUrl).';
 
 /**
  * Warn when apikey auth (including bearerToken preset) has no testEndpoint.

package/lib/commands/repair-datasource-key-skip.js

@@ -0,0 +1,39 @@
+/**
+ * Skip repair key prefix when a datasource key is already unique scoped kebab-case.
+ *
+ * @fileoverview Unique kebab datasource keys stay as-is during repair
+ */
+
+'use strict';
+
+const SCOPED_KEBAB = /^[a-z0-9]+(-[a-z0-9]+)+$/;
+
+/**
+ * @param {string} key
+ * @returns {boolean}
+ */
+function isScopedKebabKey(key) {
+  return SCOPED_KEBAB.test(String(key || '').trim());
+}
+
+/**
+ * True when key already contains a hyphen and appears once in the package.
+ * Single-token keys (persons) must still be prefixed with the system key.
+ *
+ * @param {string} key
+ * @param {string[]} allKeys
+ * @returns {boolean}
+ */
+function shouldSkipSystemKeyPrefix(key, allKeys) {
+  const trimmed = String(key || '').trim();
+  if (!isScopedKebabKey(trimmed) || trimmed.endsWith('-datasource')) {
+    return false;
+  }
+  const hits = (allKeys || []).filter((item) => String(item || '').trim() === trimmed);
+  return hits.length === 1;
+}
+
+module.exports = {
+  isScopedKebabKey,
+  shouldSkipSystemKeyPrefix
+};

package/lib/commands/repair-datasource-keys.js

@@ -17,6 +17,7 @@ const fs = require('fs');
 const { loadConfigFile, writeConfigFile } = require('../utils/config-format');
 const { backupIntegrationFile } = require('../utils/integration-file-backup');
 const { trackRepairWrite } = require('./repair-changed-files');
+const { shouldSkipSystemKeyPrefix } = require('./repair-datasource-key-skip');
 
 /**
  * Returns suffix from a canonical-format filename: <systemKey>-datasource-<suffix>.<ext>.
@@ -53,6 +54,9 @@ function isKeyAlreadyCanonical(key, systemKey, fileName) {
       return true;
     }
   }
+  if (shouldSkipSystemKeyPrefix(key, [key])) {
+    return true;
+  }
   if (!key.startsWith(systemKey + '-')) return false;
   const suffix = key.slice(systemKey.length + 1);
   if (!suffix) return false;
@@ -126,6 +130,7 @@ function normalizeDatasourceKeysAndFilenames(appPath, datasourceFiles, systemKey
 
   const slugCounts = new Map();
   const fileInfos = [];
+  const packageKeys = [];
 
   for (const fileName of datasourceFiles) {
     const filePath = path.join(appPath, fileName);
@@ -138,23 +143,30 @@ function normalizeDatasourceKeysAndFilenames(appPath, datasourceFiles, systemKey
       continue;
     }
     const key = (parsed && typeof parsed.key === 'string' && parsed.key.trim()) ? parsed.key.trim() : null;
-    if (isKeyAlreadyCanonical(key, systemKey, fileName) && isFilenameAlreadyCanonical(fileName, systemKey)) {
-      fileInfos.push({ fileName, key, skip: true });
+    if (key) packageKeys.push(key);
+    fileInfos.push({ fileName, parsed, key, skip: false, slug: null, canonicalKey: null });
+  }
+
+  for (const info of fileInfos) {
+    if (info.skip) continue;
+    const filenameCanonical = isFilenameAlreadyCanonical(info.fileName, systemKey);
+    const keyCanonical = isKeyAlreadyCanonical(info.key, systemKey, info.fileName);
+    const skipPrefix =
+      shouldSkipSystemKeyPrefix(info.key, packageKeys) &&
+      !String(info.key || '').endsWith('-datasource');
+    if ((keyCanonical || skipPrefix) && filenameCanonical) {
+      info.skip = true;
+      continue;
+    }
+    if (skipPrefix) {
+      info.canonicalKey = info.key;
       continue;
     }
-    const slug = slugFromKey(key || fileName, systemKey);
-    fileInfos.push({
-      fileName,
-      parsed,
-      key,
-      slug,
-      canonicalKey: null,
-      skip: false
-    });
+    info.slug = slugFromKey(info.key || info.fileName, systemKey);
   }
 
   for (const info of fileInfos) {
-    if (info.skip) continue;
+    if (info.skip || info.canonicalKey) continue;
     const slug = info.slug;
     const n = (slugCounts.get(slug) || 0) + 1;
     slugCounts.set(slug, n);

package/lib/commands/repair-rbac.js

@@ -29,6 +29,7 @@ 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'];
@@ -47,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);
 }
 
 /**

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
+};