@pellux/goodvibes-agent 0.1.0

package/src/input/onboarding/handler-onboarding-routes.ts

@@ -0,0 +1,125 @@
+import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
+import {
+  getOnboardingWizardVisibleFieldCount,
+  type OnboardingWizardAction,
+  type OnboardingWizardController,
+} from './onboarding-wizard.ts';
+
+type OnboardingRouteState = {
+  onboardingWizard: OnboardingWizardController;
+  getViewportHeight: () => number;
+  requestRender: () => void;
+  handleEscape: () => void;
+  openModelPickerWithTarget?: (
+    target: import('../model-picker.ts').ModelPickerTarget,
+    source?: 'settings' | 'onboarding',
+  ) => boolean;
+  onAction?: (action: OnboardingWizardAction) => void;
+};
+
+function activateSelection(state: OnboardingRouteState): void {
+  state.onboardingWizard.activateSelected();
+  const target = state.onboardingWizard.consumePendingModelPickerTarget();
+  if (target !== null) {
+    if (state.openModelPickerWithTarget) state.openModelPickerWithTarget(target, 'onboarding');
+    else state.onboardingWizard.clearPendingModelPickerTarget();
+  }
+  const action = state.onboardingWizard.consumePendingAction();
+  if (action !== null) state.onAction?.(action);
+}
+
+function isEnterKey(token: InputToken): boolean {
+  return token.type === 'key' && (token.logicalName === 'enter' || token.logicalName === 'return');
+}
+
+function getKeyTextInput(token: Extract<InputToken, { type: 'key' }>): string | null {
+  if (token.ctrl || token.meta) return null;
+  if (token.logicalName === 'space') return ' ';
+  if (token.logicalName.length !== 1) return null;
+  if (token.shift && token.logicalName >= 'a' && token.logicalName <= 'z') {
+    return token.logicalName.toUpperCase();
+  }
+  return token.logicalName;
+}
+
+export function handleOnboardingWizardToken(state: OnboardingRouteState, token: InputToken): boolean {
+  if (!state.onboardingWizard.active) return false;
+
+  if (state.onboardingWizard.hydrationPending || state.onboardingWizard.hydrationError !== null) {
+    if (token.type === 'key' && token.logicalName === 'escape') state.handleEscape();
+    state.requestRender();
+    return true;
+  }
+
+  const visibleFields = getOnboardingWizardVisibleFieldCount(state.getViewportHeight());
+  const editing = state.onboardingWizard.isEditingTextField();
+
+  if (token.type === 'key') {
+    if (token.logicalName === 'escape') {
+      if (editing) state.onboardingWizard.cancelEdit();
+      else state.handleEscape();
+      return true;
+    }
+
+    if (editing) {
+      if (isEnterKey(token)) {
+        state.onboardingWizard.commitEdit();
+      } else if ((token.ctrl && token.logicalName === 'u') || token.logicalName === 'delete') {
+        state.onboardingWizard.clearEditingValue();
+      } else if (token.logicalName === 'backspace') {
+        state.onboardingWizard.editBackspace();
+      } else {
+        const textInput = getKeyTextInput(token);
+        if (textInput !== null) state.onboardingWizard.editChar(textInput);
+      }
+    } else if (token.logicalName === 'left') {
+      state.onboardingWizard.prevStep();
+    } else if (token.logicalName === 'right') {
+      state.onboardingWizard.nextStep();
+    } else if (token.logicalName === 'tab') {
+      if (token.shift) state.onboardingWizard.prevStep();
+      else state.onboardingWizard.nextStep();
+    } else if (token.logicalName === 'up') {
+      state.onboardingWizard.moveSelection(-1, visibleFields);
+    } else if (token.logicalName === 'down') {
+      state.onboardingWizard.moveSelection(1, visibleFields);
+    } else if (token.logicalName === 'pageup') {
+      state.onboardingWizard.pageSelection(-1, visibleFields);
+    } else if (token.logicalName === 'pagedown') {
+      state.onboardingWizard.pageSelection(1, visibleFields);
+    } else if (token.logicalName === 'home') {
+      state.onboardingWizard.selectFirst(visibleFields);
+    } else if (token.logicalName === 'end') {
+      state.onboardingWizard.selectLast(visibleFields);
+    } else {
+      const textInput = getKeyTextInput(token);
+      if (textInput !== null && state.onboardingWizard.beginSelectedTextInput(textInput)) {
+        state.requestRender();
+        return true;
+      }
+      if (isEnterKey(token) || token.logicalName === 'space') {
+        activateSelection(state);
+      } else if ((token.ctrl && token.logicalName === 'u') || token.logicalName === 'delete') {
+        state.onboardingWizard.clearSelectedTextField();
+      } else if (token.logicalName === 'backspace') {
+        state.onboardingWizard.editBackspace();
+      }
+    }
+  } else if (token.type === 'text') {
+    if (editing) {
+      state.onboardingWizard.editChar(token.value);
+    } else if (state.onboardingWizard.beginSelectedTextInput(token.value)) {
+      // Direct typing into selected inputs behaves like a real form field.
+    } else if (token.value === ' ') {
+      activateSelection(state);
+    } else if (/^[1-9]$/.test(token.value)) {
+      const stepIndex = Number(token.value) - 1;
+      if (stepIndex < state.onboardingWizard.steps.length) {
+        state.onboardingWizard.setStep(stepIndex);
+      }
+    }
+  }
+
+  state.requestRender();
+  return true;
+}

package/src/input/onboarding/onboarding-runtime-status.ts

@@ -0,0 +1,87 @@
+import type { HostServiceStatus } from '@/runtime/index.ts';
+
+export interface OnboardingExternalServiceState {
+  readonly daemonRunning?: boolean;
+  readonly daemonPortInUse?: boolean;
+  readonly httpListenerRunning?: boolean;
+  readonly httpListenerPortInUse?: boolean;
+  readonly daemonStatus?: HostServiceStatus;
+  readonly httpListenerStatus?: HostServiceStatus;
+}
+
+export type OnboardingRuntimeEndpoint = 'daemon' | 'httpListener';
+
+export function runtimePortDiagnostic(
+  binding: { readonly label: string; readonly host: string; readonly port: number },
+  portInUse: boolean | undefined,
+  status?: HostServiceStatus,
+): string {
+  if (status) {
+    const reason = status.reason ? ` ${status.reason}` : '';
+    if (status.mode === 'blocked') {
+      return `The configured endpoint ${status.baseUrl} is occupied but was not usable by this TUI instance.${reason}`;
+    }
+    if (status.mode === 'disabled') {
+      return `The configured endpoint ${status.baseUrl} is disabled in the runtime service configuration.${reason}`;
+    }
+    if (status.mode === 'unavailable') {
+      return `The configured endpoint ${status.baseUrl} is unavailable after startup or restart.${reason}`;
+    }
+    if (status.mode === 'external') {
+      const version = status.version ? ` version ${status.version}` : '';
+      return `An existing GoodVibes service was verified at ${status.baseUrl}${version}.`;
+    }
+    return `An embedded GoodVibes service is running at ${status.baseUrl}.`;
+  }
+  if (portInUse) {
+    return `The configured port ${binding.host}:${binding.port} is occupied after restart; another GoodVibes process, an overlapping restart, or another service may still own it.`;
+  }
+  return `No process is listening on ${binding.host}:${binding.port} after restart.`;
+}
+
+export function getRuntimeEndpointStatus(
+  state: OnboardingExternalServiceState | undefined,
+  endpoint: OnboardingRuntimeEndpoint,
+): HostServiceStatus | undefined {
+  return endpoint === 'daemon' ? state?.daemonStatus : state?.httpListenerStatus;
+}
+
+export function isRuntimeEndpointActive(
+  state: OnboardingExternalServiceState | undefined,
+  endpoint: OnboardingRuntimeEndpoint,
+): boolean {
+  const status = getRuntimeEndpointStatus(state, endpoint);
+  if (status) return status.mode === 'embedded' || status.mode === 'external';
+  return endpoint === 'daemon'
+    ? state?.daemonRunning === true
+    : state?.httpListenerRunning === true;
+}
+
+export function isRuntimeEndpointOccupyingConfiguredPort(
+  state: OnboardingExternalServiceState | undefined,
+  endpoint: OnboardingRuntimeEndpoint,
+): boolean {
+  const status = getRuntimeEndpointStatus(state, endpoint);
+  if (status) return status.mode === 'embedded' || status.mode === 'external' || status.mode === 'blocked';
+  return endpoint === 'daemon'
+    ? state?.daemonRunning === true || state?.daemonPortInUse === true
+    : state?.httpListenerRunning === true || state?.httpListenerPortInUse === true;
+}
+
+export function formatRuntimeActiveSuccessMessage(
+  endpoint: OnboardingRuntimeEndpoint,
+  state: OnboardingExternalServiceState | undefined,
+): string {
+  const status = getRuntimeEndpointStatus(state, endpoint);
+  const label = endpoint === 'daemon' ? 'GoodVibes daemon' : 'HTTP listener';
+  if (status?.mode === 'external') {
+    const version = status.version ? ` version ${status.version}` : '';
+    return `${label} is already running as a verified external GoodVibes service at ${status.baseUrl}${version}.`;
+  }
+  if (status?.mode === 'embedded') {
+    return `${label} is running as an embedded service at ${status.baseUrl}.`;
+  }
+  return endpoint === 'daemon'
+    ? 'The GoodVibes daemon is running with the applied onboarding settings.'
+    : 'The HTTP listener is running with the applied onboarding settings.';
+}

package/src/input/onboarding/onboarding-wizard-apply.ts

@@ -0,0 +1,277 @@
+import type { OnboardingAcknowledgementTarget, OnboardingApplyOperation, OnboardingApplyRequest } from '../../runtime/onboarding/index.ts';
+import { formatProviderModel } from '../../config/provider-model.ts';
+import { getServerSurfaceFeatureFlags } from '../../runtime/surface-feature-flags.ts';
+import {
+  buildCloudflareApiTokenRef,
+  buildCloudflareOperationalTokenRef,
+  getCloudflareBatchMode,
+  getCloudflareComponentSelection,
+  getCloudflareSetupSource,
+  shouldShowCloudflareStep,
+} from './onboarding-wizard-cloudflare.ts';
+import {
+  EXTERNAL_SURFACE_SPECS,
+  getExternalSurfaceAutoStartDefaultValue,
+  getExternalSurfaceAutoStartFieldId,
+  isExternalSurfaceSelectedByDefault,
+} from './onboarding-wizard-external-surfaces.ts';
+import { buildGoodVibesSecretKey, buildGoodVibesSecretRef, isLoopbackAddress, isSecretReferenceValue } from './onboarding-wizard-helpers.ts';
+import type { OnboardingWizardController } from './onboarding-wizard.ts';
+
+export function buildOnboardingApplyRequest(controller: OnboardingWizardController): OnboardingApplyRequest {
+    const operations: OnboardingApplyOperation[] = [];
+    const setConfig = (
+      key: Extract<OnboardingApplyOperation, { kind: 'set-config' }>['key'],
+      value: unknown,
+    ): void => {
+      operations.push({ kind: 'set-config', key, value });
+    };
+    const enableFeatureFlags = (flagIds: readonly string[]): void => {
+      for (const flagId of flagIds) setConfig(`featureFlags.${flagId}`, 'enabled');
+    };
+    const acknowledge = (target: OnboardingAcknowledgementTarget, fieldId: string): void => {
+      operations.push({
+        kind: 'acknowledge',
+        target,
+        acknowledged: controller.getBooleanFieldValue(fieldId, false),
+      });
+    };
+    const setSecret = (key: string, value: string): void => {
+      if (value.length === 0) return;
+      const medium = controller.getSelectedSecretMedium();
+      operations.push({
+        kind: 'set-secret',
+        key,
+        value,
+        scope: 'project',
+        medium,
+      });
+    };
+    const setMaskedConfig = (
+      key: Extract<OnboardingApplyOperation, { kind: 'set-config' }>['key'],
+      value: string,
+    ): void => {
+      if (value.length === 0 || isSecretReferenceValue(value)) {
+        setConfig(key, value);
+        return;
+      }
+
+      const secretKey = buildGoodVibesSecretKey(key);
+      setSecret(secretKey, value);
+      setConfig(key, buildGoodVibesSecretRef(secretKey));
+    };
+
+    const requestedAdminPassword = controller.getStringFieldValue('accounts.admin-password', '');
+    const shouldEnsureAuthUser = controller.requiresAuthBootstrap() || requestedAdminPassword.length > 0;
+    if (shouldEnsureAuthUser) {
+      operations.push({
+        kind: 'ensure-auth-user',
+        username: controller.getStringFieldValue('accounts.admin-username', controller.getDefaultAdminUsername()),
+        password: requestedAdminPassword,
+        roles: ['admin'],
+        createSession: true,
+        retireBootstrapCredential: controller.hasBootstrapCredentialPresent(),
+      });
+    }
+
+    // GoodVibes Agent consumes an externally managed daemon. Onboarding must not
+    // enable, disable, bind, expose, start, stop, or restart daemon/listener/web
+    // lifecycle settings; provider/auth/local Agent state is the owned surface.
+
+    const defaultModel = controller.modelSelectionState.get('main');
+    if (defaultModel && defaultModel.enabled !== false && defaultModel.providerId.length > 0 && defaultModel.modelId.length > 0) {
+      setConfig('provider.model', formatProviderModel(defaultModel.providerId, defaultModel.modelId));
+    }
+    setConfig('provider.reasoningEffort', controller.getStringFieldValue('default-model.reasoning', controller.runtimeSnapshot?.providerRouting.primaryReasoningEffort ?? 'medium'));
+    setConfig('behavior.hitlMode', controller.getStringFieldValue('experience.hitl', controller.runtimeSnapshot?.runtimeDefaults.behavior.hitlMode ?? 'balanced'));
+    setConfig('behavior.guidanceMode', controller.getStringFieldValue('experience.guidance', controller.runtimeSnapshot?.runtimeDefaults.behavior.guidanceMode ?? 'minimal'));
+    setConfig('permissions.mode', controller.getStringFieldValue('experience.permissions', controller.runtimeSnapshot?.runtimeDefaults.permissionsMode ?? 'prompt'));
+    setConfig('storage.secretPolicy', controller.getStringFieldValue('external-services.secret-policy', controller.runtimeSnapshot?.runtimeDefaults.secretStoragePolicy ?? 'preferred_secure'));
+
+    setSecret('OPENAI_API_KEY', controller.getStringFieldValue('providers.openai-api-key', ''));
+
+    if (shouldShowCloudflareStep(controller)) {
+      addCloudflareOperations(controller, operations, setSecret);
+    }
+
+    const externalIntegrations = controller.isCapabilitySelected('external-integrations');
+    const enabledExternalSurfaceIds: string[] = [];
+    for (const surface of EXTERNAL_SURFACE_SPECS) {
+      const selected = externalIntegrations
+        && controller.getBooleanFieldValue(
+          surface.enabledFieldId,
+          isExternalSurfaceSelectedByDefault(surface, controller.runtimeSnapshot),
+        );
+      const autoStart = selected
+        && controller.getStringFieldValue(
+          getExternalSurfaceAutoStartFieldId(surface),
+          getExternalSurfaceAutoStartDefaultValue(surface, controller.runtimeSnapshot),
+        ) === 'yes';
+      setConfig(surface.enabledConfigKey, autoStart);
+      if (!selected) continue;
+      enabledExternalSurfaceIds.push(surface.id);
+
+      for (const setupField of surface.fields) {
+        const fallback = setupField.defaultValue(controller.runtimeSnapshot);
+        if (setupField.valueType === 'number') {
+          setConfig(
+            setupField.configKey,
+            controller.getNumberFieldValue(
+              setupField.id,
+              setupField.defaultNumber ?? (Number.parseInt(fallback, 10) || 0),
+              setupField.min,
+              setupField.max,
+            ),
+          );
+          continue;
+        }
+
+        const value = controller.getStringFieldValue(setupField.id, fallback);
+        if (setupField.kind === 'masked') setMaskedConfig(setupField.configKey, value);
+        else setConfig(setupField.configKey, value);
+      }
+    }
+    enableFeatureFlags(getServerSurfaceFeatureFlags({
+      serverBacked: false,
+      web: false,
+      externalSurfaces: enabledExternalSurfaceIds,
+    }));
+
+    acknowledge('providers', 'providers.reviewed');
+    acknowledge('subscriptions', 'accounts.subscriptions');
+    acknowledge('auth', 'accounts.auth');
+
+    return {
+      mode: controller.mode,
+      source: 'wizard',
+      operations,
+    };
+  }
+
+function addCloudflareOperations(
+  controller: OnboardingWizardController,
+  operations: OnboardingApplyOperation[],
+  setSecret: (key: string, value: string) => void,
+): void {
+    const setConfig = (
+      key: Extract<OnboardingApplyOperation, { kind: 'set-config' }>['key'],
+      value: unknown,
+    ): void => {
+      operations.push({ kind: 'set-config', key, value });
+    };
+
+    const config = controller.runtimeSnapshot?.config.cloudflare;
+    const enabledDefault = controller.isCapabilitySelected('cloudflare-batch') || config?.enabled === true;
+    const enabled = controller.getBooleanFieldValue('cloudflare.enabled', enabledDefault);
+    const components = getCloudflareComponentSelection(controller);
+    const batchMode = enabled ? getCloudflareBatchMode(controller) : 'off';
+    const setupSource = getCloudflareSetupSource(controller);
+    const existingApiTokenRef = config?.apiTokenRef ?? '';
+    let apiTokenRef = existingApiTokenRef;
+
+    if (!enabled) {
+      setConfig('cloudflare.enabled', false);
+      setConfig('batch.mode', 'off');
+      setConfig('batch.queueBackend', 'local');
+      return;
+    }
+
+    if (setupSource === 'operational-env') {
+      apiTokenRef = buildCloudflareApiTokenRef(
+        controller.getStringFieldValue('cloudflare.operational-env-name', 'CLOUDFLARE_API_TOKEN'),
+      );
+    } else if (setupSource === 'operational-token') {
+      const token = controller.getStringFieldValue('cloudflare.operational-token', '');
+      if (token.length > 0) {
+        setSecret('CLOUDFLARE_API_TOKEN', token);
+        apiTokenRef = buildCloudflareOperationalTokenRef();
+      }
+    }
+
+    setConfig('cloudflare.enabled', true);
+    setConfig('cloudflare.freeTierMode', controller.getStringFieldValue('cloudflare.free-tier-mode', config?.freeTierMode === false ? 'no' : 'yes') === 'yes');
+    setConfig('cloudflare.accountId', controller.getStringFieldValue('cloudflare.account-id', config?.accountId ?? ''));
+    setConfig('cloudflare.apiTokenRef', apiTokenRef);
+    setConfig('cloudflare.zoneId', controller.getStringFieldValue('cloudflare.zone-id', config?.zoneId ?? ''));
+    setConfig('cloudflare.zoneName', controller.getStringFieldValue('cloudflare.zone-name', config?.zoneName ?? ''));
+    setConfig('cloudflare.workerName', controller.getStringFieldValue('cloudflare.worker-name', config?.workerName ?? 'goodvibes-batch-worker'));
+    setConfig('cloudflare.workerSubdomain', controller.getStringFieldValue('cloudflare.worker-subdomain', config?.workerSubdomain ?? ''));
+    setConfig('cloudflare.workerHostname', controller.getStringFieldValue('cloudflare.worker-hostname', config?.workerHostname ?? ''));
+    setConfig('cloudflare.workerBaseUrl', controller.getStringFieldValue('cloudflare.worker-base-url', config?.workerBaseUrl ?? ''));
+    setConfig('cloudflare.daemonBaseUrl', controller.getStringFieldValue('cloudflare.daemon-base-url', config?.daemonBaseUrl ?? ''));
+    setConfig('cloudflare.daemonHostname', controller.getStringFieldValue('cloudflare.daemon-hostname', config?.daemonHostname ?? ''));
+    setConfig('cloudflare.workerCron', controller.getStringFieldValue('cloudflare.worker-cron', config?.workerCron ?? '*/5 * * * *'));
+    setConfig('cloudflare.queueName', controller.getStringFieldValue('cloudflare.queue-name', config?.queueName ?? 'goodvibes-batch'));
+    setConfig('cloudflare.deadLetterQueueName', controller.getStringFieldValue('cloudflare.dead-letter-queue-name', config?.deadLetterQueueName ?? 'goodvibes-batch-dlq'));
+    setConfig('cloudflare.tunnelName', controller.getStringFieldValue('cloudflare.tunnel-name', config?.tunnelName ?? 'goodvibes-daemon'));
+    setConfig('cloudflare.tunnelId', controller.getStringFieldValue('cloudflare.tunnel-id', config?.tunnelId ?? ''));
+    setConfig('cloudflare.tunnelTokenRef', controller.getStringFieldValue('cloudflare.tunnel-token-ref', config?.tunnelTokenRef ?? ''));
+    setConfig('cloudflare.accessAppId', controller.getStringFieldValue('cloudflare.access-app-id', config?.accessAppId ?? ''));
+    setConfig('cloudflare.accessServiceTokenId', controller.getStringFieldValue('cloudflare.access-service-token-id', config?.accessServiceTokenId ?? ''));
+    setConfig('cloudflare.accessServiceTokenRef', controller.getStringFieldValue('cloudflare.access-service-token-ref', config?.accessServiceTokenRef ?? ''));
+    setConfig('cloudflare.kvNamespaceName', controller.getStringFieldValue('cloudflare.kv-namespace-name', config?.kvNamespaceName ?? 'goodvibes-runtime'));
+    setConfig('cloudflare.kvNamespaceId', controller.getStringFieldValue('cloudflare.kv-namespace-id', config?.kvNamespaceId ?? ''));
+    setConfig('cloudflare.durableObjectNamespaceName', controller.getStringFieldValue('cloudflare.do-namespace-name', config?.durableObjectNamespaceName ?? 'GoodVibesCoordinator'));
+    setConfig('cloudflare.durableObjectNamespaceId', controller.getStringFieldValue('cloudflare.do-namespace-id', config?.durableObjectNamespaceId ?? ''));
+    setConfig('cloudflare.r2BucketName', controller.getStringFieldValue('cloudflare.r2-bucket-name', config?.r2BucketName ?? 'goodvibes-artifacts'));
+    setConfig('cloudflare.secretsStoreName', controller.getStringFieldValue('cloudflare.secrets-store-name', config?.secretsStoreName ?? 'goodvibes'));
+    setConfig('cloudflare.secretsStoreId', controller.getStringFieldValue('cloudflare.secrets-store-id', config?.secretsStoreId ?? ''));
+    setConfig('cloudflare.maxQueueOpsPerDay', controller.getNumberFieldValue('cloudflare.max-queue-ops-per-day', config?.maxQueueOpsPerDay ?? 10000, 1));
+    setConfig('batch.mode', batchMode);
+    setConfig('batch.queueBackend', batchMode !== 'off' && components.queues ? 'cloudflare' : 'local');
+  }
+
+export function addNetworkOperations(
+  controller: OnboardingWizardController,
+    operations: OnboardingApplyOperation[],
+    customNetwork: boolean,
+    enabled: {
+      readonly controlPlane: boolean;
+      readonly controlPlaneRemote: boolean;
+      readonly httpListener: boolean;
+      readonly web: boolean;
+    },
+  ): void {
+    const setConfig = (
+      key: Extract<OnboardingApplyOperation, { kind: 'set-config' }>['key'],
+      value: unknown,
+    ): void => {
+      operations.push({ kind: 'set-config', key, value });
+    };
+    const networkFacingEnabled = {
+      controlPlane: enabled.controlPlaneRemote,
+      httpListener: enabled.httpListener,
+      web: enabled.web,
+    };
+    const sharedIpDefault = controller.getSharedIpDefault(networkFacingEnabled);
+    const sharedIp = controller.getBooleanFieldValue('network.shared-ip', sharedIpDefault);
+    const sharedHost = controller.getStringFieldValue('network.shared-ip-address', controller.getSharedIpHostDefault(networkFacingEnabled)) || '0.0.0.0';
+    const controlPlaneHost = sharedIp
+      ? sharedHost
+      : controller.getStringFieldValue('network.service-ip', controller.runtimeSnapshot?.bindSettings.controlPlane.host ?? '0.0.0.0');
+    const httpListenerHost = sharedIp
+      ? sharedHost
+      : controller.getStringFieldValue('network.webhook-ip', controller.runtimeSnapshot?.bindSettings.httpListener.host ?? '0.0.0.0');
+    const webHost = sharedIp
+      ? sharedHost
+      : controller.getStringFieldValue('network.browser-ip', controller.runtimeSnapshot?.bindSettings.web.host ?? '0.0.0.0');
+
+    if (enabled.controlPlane) {
+      setConfig('controlPlane.hostMode', enabled.controlPlaneRemote ? (customNetwork ? 'custom' : 'network') : 'local');
+      setConfig('controlPlane.host', enabled.controlPlaneRemote ? (customNetwork ? controlPlaneHost : '0.0.0.0') : '127.0.0.1');
+      setConfig('controlPlane.port', controller.getPortFieldValue('network.service-port', controller.runtimeSnapshot?.bindSettings.controlPlane.port ?? 3421));
+      setConfig('controlPlane.allowRemote', enabled.controlPlaneRemote && (customNetwork ? !isLoopbackAddress(controlPlaneHost) : true));
+    }
+
+    if (enabled.httpListener) {
+      setConfig('httpListener.hostMode', customNetwork ? 'custom' : 'network');
+      setConfig('httpListener.host', customNetwork ? httpListenerHost : '0.0.0.0');
+      setConfig('httpListener.port', controller.getPortFieldValue('network.webhook-port', controller.runtimeSnapshot?.bindSettings.httpListener.port ?? 3422));
+    }
+
+    if (enabled.web) {
+      setConfig('web.hostMode', customNetwork ? 'custom' : 'network');
+      setConfig('web.host', customNetwork ? webHost : '0.0.0.0');
+      setConfig('web.port', controller.getPortFieldValue('network.browser-port', controller.runtimeSnapshot?.bindSettings.web.port ?? 3423));
+    }
+  }