config-assembly.ts

import { WrapperConfig } from '../../types';
import { applyAgentTimeout } from '../../option-parsers';
import { logger } from '../../logger';
import { buildConfig } from '../build-config';
import { LogAndLimitsResult } from './log-and-limits';
import { NetworkOptionsResult } from './network-options';
import { AgentOptionsResult } from './agent-options';
import { validateInfrastructureOptions, applyRateLimitConfig, validateFeatureFlagCompatibility } from './infrastructure-validator';
import { applySecurityMode } from './security-mode';
import { validateHostAccessConfig } from './network-access-validator';
import { validateApiProxyOptions, validateCopilotModelOption } from './api-proxy-validator';
import {
  assertCloudHypervisorPreSecurityCompatibility,
  assertCloudHypervisorRuntimeCompatibility,
  assertCloudHypervisorSelection,
  isPrimaryCloudHypervisorRuntime,
  requiresCloudHypervisorInfrastructure,
  usesCloudHypervisorEnclaveRuntime,
} from '../../cloud-hypervisor/runtime-validation';
import {
  assertNvxRuntimeCompatibility,
  assertNvxSelection,
  isPrimaryNvxRuntime,
} from '../../nvx/runtime-validation';
import { assertProtectedCommandOutputCaptureSupported } from '../../protected-command-output-capture';
import { assertFilesystemWritePolicyCompatibility } from '../../filesystem-policy';
import {
  formatCloudHypervisorDockerFallbackWarning,
  isCloudHypervisorUnsupportedHostError,
} from '../../cloud-hypervisor/errors';

function fallBackCloudHypervisorToDocker(config: WrapperConfig, error: unknown): void {
  logger.warn(formatCloudHypervisorDockerFallbackWarning(error));
  config.containerRuntime = undefined;
  config.cloudHypervisor = undefined;
}

// ---------------------------------------------------------------------------
// Public API
// ---------------------------------------------------------------------------

/**
 * Assembles the {@link WrapperConfig} from pre-validated partial results and
 * runs all post-assembly validation guards.
 *
 * This is the final stage of the validation pipeline.  Every input must
 * already be validated by the earlier stages; this function only:
 *  1. Calls {@link buildConfig} to merge everything into a single object.
 *  2. Runs post-config guards that require the fully-assembled config (docker
 *     host URI format, rate limits, feature-flag compatibility, port rules,
 *     API-proxy configuration warnings).
 *
 * Calls `process.exit(1)` on any validation failure so the caller always
 * receives a fully-validated, ready-to-use config object.
 */
export function assembleAndValidateConfig(
  options: Record<string, unknown>,
  agentCommand: string,
  logAndLimits: LogAndLimitsResult,
  networkOptions: NetworkOptionsResult,
  agentOptions: AgentOptionsResult,
): WrapperConfig {
  const config = buildConfig({
    options,
    agentCommand,
    logLevel: logAndLimits.logLevel,
    allowedDomains: networkOptions.allowedDomains,
    sensitiveAllowedDomains: networkOptions.sensitiveAllowedDomains,
    blockedDomains: networkOptions.blockedDomains,
    localhostDetected: networkOptions.localhostResult.localhostDetected,
    additionalEnv: agentOptions.additionalEnv,
    volumeMounts: agentOptions.volumeMounts,
    upstreamProxy: networkOptions.upstreamProxy,
    dnsServers: networkOptions.dnsServers,
    dnsServersExplicit: networkOptions.dnsServersExplicit,
    dnsOverHttps: networkOptions.dnsOverHttps,
    networkSubnet: networkOptions.networkSubnet,
    allowedUrls: agentOptions.allowedUrls,
    memoryLimit: logAndLimits.memoryLimit,
    pidsLimit: logAndLimits.pidsLimit,
    agentImage: logAndLimits.agentImage,
    modelAliases: logAndLimits.modelAliases,
    allowedModels: logAndLimits.allowedModels,
    disallowedModels: logAndLimits.disallowedModels,
    maxAiCredits: logAndLimits.maxAiCredits,
    modelMultipliers: logAndLimits.modelMultipliers,
    defaultModelMultiplier: logAndLimits.defaultModelMultiplier,
    maxModelMultiplierCap: logAndLimits.maxModelMultiplierCap,
    maxRuns: logAndLimits.maxRuns,
    maxPermissionDenied: logAndLimits.maxPermissionDenied,
    maxCacheMisses: logAndLimits.maxCacheMisses,
    resolvedCopilotApiTarget: networkOptions.resolvedCopilotApiTarget,
    resolvedCopilotApiBasePath: networkOptions.resolvedCopilotApiBasePath,
    dockerHostPathPrefix: networkOptions.dockerHostPathPrefixResolution.dockerHostPathPrefix,
  });

  try {
    assertProtectedCommandOutputCaptureSupported(config);
  } catch (error) {
    logger.error(`❌ ${error instanceof Error ? error.message : String(error)}`);
    process.exit(1);
  }
  validateInfrastructureOptions(config);
  try {
    assertCloudHypervisorSelection(config);
    assertNvxSelection(config);
  } catch (error) {
    logger.error(`❌ ${error instanceof Error ? error.message : String(error)}`);
    process.exit(1);
  }
  if (requiresCloudHypervisorInfrastructure(config)) {
    try {
      assertCloudHypervisorPreSecurityCompatibility(config);
    } catch (error) {
      logger.error(`❌ ${error instanceof Error ? error.message : String(error)}`);
      process.exit(1);
    }
  }
  applySecurityMode(config);
  try {
    assertFilesystemWritePolicyCompatibility(config);
  } catch (error) {
    logger.error(`❌ ${error instanceof Error ? error.message : String(error)}`);
    process.exit(1);
  }
  if (requiresCloudHypervisorInfrastructure(config)) {
    try {
      assertCloudHypervisorRuntimeCompatibility(config);
    } catch (error) {
      if (
        isCloudHypervisorUnsupportedHostError(error)
        && isPrimaryCloudHypervisorRuntime(config)
        && !usesCloudHypervisorEnclaveRuntime(config)
      ) {
        fallBackCloudHypervisorToDocker(config, error);
      } else {
        logger.error(`❌ ${error instanceof Error ? error.message : String(error)}`);
        process.exit(1);
      }
    }
  }
  if (isPrimaryNvxRuntime(config)) {
    // NVX never falls back to another runtime: any validation failure here
    // (missing preview flag, unsupported host, invalid artifacts) is fatal.
    try {
      assertNvxRuntimeCompatibility(config);
    } catch (error) {
      logger.error(`❌ ${error instanceof Error ? error.message : String(error)}`);
      process.exit(1);
    }
  }
  applyAgentTimeout(options.agentTimeout as string | undefined, config, logger);
  applyRateLimitConfig(config, options);
  validateFeatureFlagCompatibility(config);
  validateHostAccessConfig(config, networkOptions);
  validateApiProxyOptions(config, networkOptions);
  validateCopilotModelOption(config, agentOptions);

  return config;
}