@aifabrix/builder 2.54.1 → 2.55.2

package/lib/commands/agent-kit.js

@@ -0,0 +1,417 @@
+/**
+ * `aifabrix agent-kit` command group.
+ * @fileoverview Install, init, status, update, validate, remote create, start
+ */
+
+'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 { runStart } = require('../agent-kit/start');
+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_GROUP_HELP,
+  REMOTE_HELP,
+  START_HELP,
+  HOST_OPTION_HELP,
+  APPROVE_ALL_OPTION_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 {object} json
+ * @param {boolean} asJson
+ * @returns {void}
+ */
+function emitStartReport(json, asJson) {
+  if (asJson) {
+    logger.log(JSON.stringify(json, null, 2));
+    return;
+  }
+  logger.log(`App        ${json.app}`);
+  logger.log(`Session    ${json.session}`);
+  if (json.remoteControlName) {
+    logger.log(`Remote     ${json.remoteControlName}`);
+  }
+  logger.log(`Path       ${json.path}`);
+  logger.log(`Launch     ${json.launch.join(' ')}`);
+  if (json.executed && json.detach) {
+    logger.log(formatSuccessLine('Session started in background'));
+    return;
+  }
+  if (json.executed) {
+    logger.log(formatSuccessLine('Session ended'));
+    return;
+  }
+  logger.log(formatSuccessLine(json.dryRun ? 'Dry-run complete' : 'Ready'));
+}
+
+/**
+ * @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);
+  addStartCommand(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>', HOST_OPTION_HELP, 'all')
+    .option('--scm <kind>', 'git or none', 'git')
+    .option('--remote', 'Create private GitHub 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 [host]', APPROVE_ALL_OPTION_HELP)
+    .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('Create a GitHub repository for this workspace and push')
+    .addHelpText('after', REMOTE_GROUP_HELP);
+  remote
+    .command('create')
+    .description('Create a private GitHub repository (origin) and push this 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>', HOST_OPTION_HELP, 'all')
+    .option('--approve-all [host]', APPROVE_ALL_OPTION_HELP)
+    .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 withHost = await enrichInitHostOptions(options, { interactive });
+        const merged = await enrichApproveAllOptions(withHost, { 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>', `${HOST_OPTION_HELP} (omit to keep recorded hosts)`)
+    .option('--approve-all [host]', APPROVE_ALL_OPTION_HELP)
+    .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;
+  }
+}
+
+/**
+ * @param {import('commander').Command} group
+ */
+function addStartCommand(group) {
+  group
+    .command('start <app>')
+    .description('Start Claude Code or Codex in tmux (does not install skills)')
+    .option('--approve-all', 'Write auto-approve config for this app only')
+    .option('--skip-approve-all', 'Do not write auto-approve configs')
+    .option('--yes', 'Same as --approve-all')
+    .option('--detach', 'Create the tmux session in the background (no attach)')
+    .option(
+      '--name <session>',
+      'tmux session name (default: last folder of this git workspace)'
+    )
+    .option(
+      '--remote-control',
+      'Claude Code only: same session on this PC, claude.ai/code, and the Claude mobile app'
+    )
+    .option('--dry-run', 'Print the launch command without starting it')
+    .option('--json', 'Machine-readable output')
+    .addHelpText('after', START_HELP)
+    .action(async(app, options) => {
+      try {
+        const json = runStart({ ...options, app });
+        emitStartReport(json, Boolean(options.json));
+      } catch (error) {
+        handleCommandError(error, 'agent-kit start');
+        process.exitCode = 1;
+      }
+    });
+}
+
+module.exports = { setupAgentKitCommands };

package/lib/commands/auth-status-user.js

@@ -0,0 +1,99 @@
+/**
+ * Resolve the signed-in username for `aifabrix auth status`.
+ *
+ * @fileoverview Unwrap controller auth/user payloads and pick a display username
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const { unwrapControllerData } = require('../identity/identity-response-helpers');
+
+/**
+ * @param {...*} values
+ * @returns {string}
+ */
+function firstNonEmptyString(...values) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) {
+      return value.trim();
+    }
+  }
+  return '';
+}
+
+/**
+ * Decode a JWT payload for display only. Does not verify the signature.
+ * @param {string} token
+ * @returns {Object|null}
+ */
+function decodeJwtPayload(token) {
+  if (!token || typeof token !== 'string') {
+    return null;
+  }
+  const parts = token.split('.');
+  if (parts.length < 2) {
+    return null;
+  }
+  try {
+    const b64 = parts[1].replace(/-/g, '+').replace(/_/g, '/');
+    const padded = b64.padEnd(Math.ceil(b64.length / 4) * 4, '=');
+    const payload = JSON.parse(Buffer.from(padded, 'base64').toString('utf8'));
+    return payload && typeof payload === 'object' ? payload : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {Object|null|undefined} user
+ * @param {string} [token]
+ * @returns {string}
+ */
+function resolveDisplayUsername(user, token) {
+  const fromUser = firstNonEmptyString(
+    user && user.username,
+    user && user.preferredUsername,
+    user && user.preferred_username,
+    user && user.email
+  );
+  if (fromUser) {
+    return fromUser;
+  }
+  const payload = decodeJwtPayload(token);
+  return firstNonEmptyString(
+    payload && payload.preferred_username,
+    payload && payload.preferredUsername,
+    payload && payload.email,
+    payload && payload.upn
+  );
+}
+
+/**
+ * @param {Object|null|undefined} response
+ * @param {string} [token]
+ * @returns {{ authenticated: boolean, user: Object|null, username: string }}
+ */
+function parseAuthUserResponse(response, token) {
+  const payload = unwrapControllerData(response);
+  if (!payload || typeof payload !== 'object') {
+    return { authenticated: false, user: null, username: '' };
+  }
+  const rawUser = payload.user && typeof payload.user === 'object' ? payload.user : null;
+  const username = resolveDisplayUsername(rawUser, token);
+  const user = username && (!rawUser || !rawUser.username)
+    ? { ...(rawUser || {}), username }
+    : rawUser;
+  return {
+    authenticated: payload.authenticated !== false,
+    user,
+    username
+  };
+}
+
+module.exports = {
+  decodeJwtPayload,
+  resolveDisplayUsername,
+  parseAuthUserResponse
+};

package/lib/commands/auth-status.js

@@ -34,6 +34,7 @@ const {
   displayStoredClientTokensSection,
   tryResolveClientTokenAuth
 } = require('./auth-status-client-tokens');
+const { parseAuthUserResponse } = require('./auth-status-user');
 
 /**
  * Format expiration date for display
@@ -71,11 +72,13 @@ async function checkDeviceToken(controllerUrl) {
     const response = await getAuthUser(controllerUrl, authConfig);
 
     if (response.success && response.data) {
+      const parsed = parseAuthUserResponse(response, deviceToken.token);
       return {
         type: 'Device Token',
         token: deviceToken.token,
-        authenticated: response.data.authenticated !== false,
-        user: response.data.user,
+        authenticated: parsed.authenticated,
+        user: parsed.user,
+        username: parsed.username,
         expiresAt: deviceToken.expiresAt
       };
     }
@@ -113,11 +116,13 @@ async function validateClientToken(token, controllerUrl, environment, appName, e
     const response = await getAuthUser(controllerUrl, authConfig);
 
     if (response.success && response.data) {
+      const parsed = parseAuthUserResponse(response, token);
       return {
         type: 'Client Token',
         token: token,
-        authenticated: response.data.authenticated !== false,
-        user: response.data.user,
+        authenticated: parsed.authenticated,
+        user: parsed.user,
+        username: parsed.username,
         expiresAt: expiresAt,
         appName: appName
       };
@@ -185,6 +190,11 @@ function displayTokenInfo(tokenInfo) {
   logger.log(`  Status: ${statusIcon} ${statusText}`);
   logger.log(`  Token Type: ${chalk.cyan(tokenInfo.type)}`);
 
+  if (tokenInfo.authenticated) {
+    const username = tokenInfo.username || (tokenInfo.user && tokenInfo.user.username);
+    logger.log(`  User: ${username ? chalk.cyan(username) : chalk.gray('—')}`);
+  }
+
   if (tokenInfo.appName) {
     logger.log(`  Application: ${chalk.cyan(tokenInfo.appName)}`);
   }

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/datasource-load-export-cli.js

@@ -7,6 +7,7 @@
 'use strict';
 
 const logger = require('../utils/logger');
+const { writeJsonEnvelopeAndExit } = require('../utils/cli-json-exit');
 const { formatBlockingError } = require('../utils/cli-test-layout-chalk');
 const { runDatasourceLoad } = require('../datasource/bulk-loader-service');
 const { runDatasourceExport } = require('../datasource/datasource-exporter-service');
@@ -82,7 +83,9 @@ async function datasourceLoadAction(datasourceKey, options) {
 
     if (options.json) {
       const { context: _ctx, ...payload } = result;
-      logger.log(JSON.stringify(payload, null, 2));
+      // exitCode 0 — write and resolve, never exit here; this action always
+      // exits unconditionally below with the real computed code.
+      await writeJsonEnvelopeAndExit(payload, 0);
     } else {
       displayDatasourceLoadTTY(result, { environment: options.env, verbose: options.verbose });
     }
@@ -112,7 +115,9 @@ async function datasourceExportAction(datasourceKey, options) {
 
     if (options.json) {
       const { context: _ctx, ...payload } = result;
-      logger.log(JSON.stringify(payload, null, 2));
+      // exitCode 0 — write and resolve, never exit here; this action always
+      // exits unconditionally below with the real computed code.
+      await writeJsonEnvelopeAndExit(payload, 0);
     } else {
       displayDatasourceExportTTY(result, { environment: options.env, verbose: options.verbose });
     }

package/lib/commands/datasource-test-trust-cli.js

@@ -7,6 +7,7 @@
 'use strict';
 
 const logger = require('../utils/logger');
+const { writeJsonEnvelopeAndExit } = require('../utils/cli-json-exit');
 const { formatBlockingError } = require('../utils/cli-test-layout-chalk');
 const { runDatasourceAgentTrust } = require('../datasource/agent-trust-run');
 const { writeTrustDebugLogAndPrint } = require('../datasource/agent-trust-debug-log');
@@ -52,7 +53,10 @@ async function finalizeDatasourceVerifyTrust(datasourceKey, options, result) {
     strict: options.strict === true
   };
   if (options.json) {
-    logger.log(JSON.stringify(result.trustRun, null, 2));
+    // exitCode 0 here means "write and resolve, never exit" — the real exit
+    // code is decided below and the caller exits unconditionally, even on
+    // success, so process.exit() must stay solely the caller's job.
+    await writeJsonEnvelopeAndExit(result.trustRun, 0);
   } else if (options.summary) {
     const tr = result.trustRun;
     logger.log(