@openshift-assisted/ui-lib 2.47.4 → 2.48.0

package/lib/ocm/components/clusterWizard/disconnected/BasicStep.tsx

@@ -15,10 +15,53 @@ import ClusterWizardNavigation from '../ClusterWizardNavigation';
 import { WithErrorBoundary } from '../../../../common/components/ErrorHandling/WithErrorBoundary';
 import InstallDisconnectedSwitch from './InstallDisconnectedSwitch';
 import { Formik } from 'formik';
+import ClustersService from '../../../services/ClustersService';
+import { handleApiError, getApiErrorMessage } from '../../../../common/api';
+import { useAlerts } from '../../../../common/components/AlertsContextProvider';
+import { AlertVariant } from '@patternfly/react-core';
+import { ClusterWizardFlowStateNew } from '../wizardTransition';
+import { useLocation, useNavigate } from 'react-router-dom-v5-compat';
+import { AxiosResponse } from 'axios';
+import { Cluster } from '@openshift-assisted/types//assisted-installer-service';
 
 const BasicStep = () => {
   const { t } = useTranslation();
   const { moveNext } = useClusterWizardContext();
+  const { addAlert } = useAlerts();
+  const [isSubmitting, setIsSubmitting] = React.useState(false);
+  const navigate = useNavigate();
+  const location = useLocation();
+  const currentPath = location.pathname;
+  let disconnectedClusterId: string | undefined;
+
+  const onNext = async () => {
+    try {
+      setIsSubmitting(true);
+      // Create cluster only - infraEnv will be created in OptionalConfigurationsStep
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const { data: disconnectedCluster }: AxiosResponse<Cluster> =
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        await ClustersService.registerDisconnected({
+          name: 'disconnected-cluster',
+          openshiftVersion: '4.19',
+        });
+      disconnectedClusterId = disconnectedCluster.id;
+      navigate(`${currentPath}/${disconnectedClusterId}`, {
+        state: ClusterWizardFlowStateNew,
+      });
+      moveNext();
+    } catch (error: unknown) {
+      handleApiError(error, () => {
+        addAlert({
+          title: 'Failed to create disconnected cluster',
+          message: getApiErrorMessage(error),
+          variant: AlertVariant.danger,
+        });
+      });
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
 
   return (
     <Formik
@@ -29,7 +72,15 @@ const BasicStep = () => {
     >
       <ClusterWizardStep
         navigation={<ClusterWizardNavigation />}
-        footer={<ClusterWizardFooter onNext={moveNext} />}
+        footer={
+          <ClusterWizardFooter
+            onNext={() => {
+              void onNext();
+            }}
+            isSubmitting={isSubmitting}
+            disconnectedClusterId={disconnectedClusterId}
+          />
+        }
       >
         <WithErrorBoundary title="Failed to load Basic step">
           <Grid hasGutter>

package/lib/ocm/components/clusterWizard/disconnected/OptionalConfigurationsStep.tsx

@@ -0,0 +1,200 @@
+import * as React from 'react';
+import { Formik, useFormikContext } from 'formik';
+import * as Yup from 'yup';
+import {
+  ClusterWizardStep,
+  DeveloperPreview,
+  getRichTextValidation,
+  sshPublicKeyValidationSchema,
+  pullSecretValidationSchema,
+  getFormikErrorFields,
+} from '../../../../common';
+import { Split, SplitItem, Grid, GridItem, Form, Content, Checkbox } from '@patternfly/react-core';
+import { useClusterWizardContext } from '../ClusterWizardContext';
+import ClusterWizardFooter from '../ClusterWizardFooter';
+import ClusterWizardNavigation from '../ClusterWizardNavigation';
+import { WithErrorBoundary } from '../../../../common/components/ErrorHandling/WithErrorBoundary';
+import UploadSSH from '../../../../common/components/clusterConfiguration/UploadSSH';
+import PullSecretField from '../../../../common/components/ui/formik/PullSecretField';
+import { isInOcm, handleApiError, getApiErrorMessage } from '../../../../common/api';
+import { useAlerts } from '../../../../common/components/AlertsContextProvider';
+import { AlertVariant } from '@patternfly/react-core';
+import InfraEnvsService from '../../../services/InfraEnvsService';
+import { InfraEnvsAPI } from '../../../services/apis';
+import usePullSecret from '../../../hooks/usePullSecret';
+import { useParams } from 'react-router-dom-v5-compat';
+import ClustersService from '../../../services/ClustersService';
+
+type OptionalConfigurationsFormValues = {
+  sshPublicKey?: string;
+  pullSecret?: string;
+};
+
+const PullSecretSync: React.FC<{ pullSecret?: string }> = ({ pullSecret }) => {
+  const { setFieldValue } = useFormikContext<OptionalConfigurationsFormValues>();
+
+  React.useEffect(() => {
+    if (pullSecret !== undefined) {
+      setFieldValue('pullSecret', pullSecret);
+    }
+  }, [pullSecret, setFieldValue]);
+
+  return null;
+};
+
+const OptionalConfigurationsStep = () => {
+  const pullSecret = usePullSecret() || '';
+  const { clusterId } = useParams<{ clusterId: string }>();
+  const [cluster, setCluster] = React.useState<{ id: string } | null>(null);
+
+  const { moveNext, moveBack, setDisconnectedInfraEnv, disconnectedInfraEnv } =
+    useClusterWizardContext();
+  const { addAlert } = useAlerts();
+  const [editPullSecret, setEditPullSecret] = React.useState(false);
+
+  React.useEffect(() => {
+    const fetchCluster = async () => {
+      if (!clusterId) {
+        return;
+      }
+      try {
+        const fetchedCluster = await ClustersService.get(clusterId);
+        setCluster(fetchedCluster);
+      } catch (error) {
+        handleApiError(error, () => {
+          addAlert({
+            title: 'Failed to fetch cluster',
+            message: getApiErrorMessage(error),
+            variant: AlertVariant.danger,
+          });
+        });
+      }
+    };
+    void fetchCluster();
+  }, [clusterId, addAlert]);
+
+  const validationSchema = React.useMemo(
+    () =>
+      Yup.object<OptionalConfigurationsFormValues>().shape({
+        sshPublicKey: sshPublicKeyValidationSchema,
+        pullSecret: pullSecretValidationSchema,
+      }),
+    [],
+  );
+
+  const initialValues: OptionalConfigurationsFormValues = {
+    sshPublicKey: '',
+    pullSecret: pullSecret,
+  };
+
+  return (
+    <Formik
+      initialValues={initialValues}
+      validate={getRichTextValidation<OptionalConfigurationsFormValues>(validationSchema)}
+      onSubmit={async (values) => {
+        if (!cluster || !cluster.id) {
+          addAlert({
+            title: 'Missing cluster',
+            message: 'Cluster must be created before configuring infrastructure environment',
+            variant: AlertVariant.danger,
+          });
+          return;
+        }
+
+        try {
+          // Check if infraEnv already exists
+          if (disconnectedInfraEnv && disconnectedInfraEnv.id) {
+            // Update existing infraEnv
+            const updateParams = {
+              pullSecret: values.pullSecret || pullSecret,
+              ...(values.sshPublicKey && { sshAuthorizedKey: values.sshPublicKey }),
+            };
+            const { data: updatedInfraEnv } = await InfraEnvsAPI.update(
+              disconnectedInfraEnv.id,
+              updateParams,
+            );
+            setDisconnectedInfraEnv(updatedInfraEnv);
+            moveNext();
+          } else {
+            // Create infraEnv with all params
+            const createParams = {
+              name: `disconnected-cluster_infra-env`,
+              pullSecret: values.pullSecret || pullSecret,
+              clusterId: cluster.id,
+              openshiftVersion: '4.19',
+              cpuArchitecture: 'x86_64' as const,
+              ...(values.sshPublicKey && { sshAuthorizedKey: values.sshPublicKey }),
+            };
+            const createdInfraEnv = await InfraEnvsService.create(createParams);
+            setDisconnectedInfraEnv(createdInfraEnv);
+            moveNext();
+          }
+        } catch (error) {
+          handleApiError(error, () => {
+            addAlert({
+              title:
+                disconnectedInfraEnv && disconnectedInfraEnv.id
+                  ? 'Failed to update infrastructure environment'
+                  : 'Failed to create infrastructure environment',
+              message: getApiErrorMessage(error),
+              variant: AlertVariant.danger,
+            });
+          });
+        }
+      }}
+    >
+      {({ submitForm, isValid, errors, touched, isSubmitting }) => {
+        const errorFields = getFormikErrorFields(errors, touched);
+        const handleNext = () => {
+          void submitForm(); // This will trigger onSubmit
+        };
+
+        return (
+          <ClusterWizardStep
+            navigation={<ClusterWizardNavigation />}
+            footer={
+              <ClusterWizardFooter
+                disconnectedClusterId={clusterId}
+                onNext={handleNext} // Changed from moveNext
+                onBack={moveBack}
+                isNextDisabled={!isValid}
+                errorFields={errorFields}
+                isSubmitting={isSubmitting}
+              />
+            }
+          >
+            <WithErrorBoundary title="Failed to load Optional Configurations step">
+              <PullSecretSync pullSecret={pullSecret} />
+              <Grid hasGutter>
+                <GridItem>
+                  <Split>
+                    <SplitItem>
+                      <Content component="h2">Optional configurations</Content>
+                    </SplitItem>
+                    <SplitItem>
+                      <DeveloperPreview />
+                    </SplitItem>
+                  </Split>
+                </GridItem>
+                <GridItem>
+                  <Form id="wizard-cluster-optional-configurations__form">
+                    <UploadSSH />
+                    <Checkbox
+                      label="Edit pull secret"
+                      isChecked={editPullSecret}
+                      onChange={(_, checked) => setEditPullSecret(checked)}
+                      id="edit-pull-secret-checkbox"
+                    />
+                    {(editPullSecret || !pullSecret) && <PullSecretField isOcm={isInOcm} />}
+                  </Form>
+                </GridItem>
+              </Grid>
+            </WithErrorBoundary>
+          </ClusterWizardStep>
+        );
+      }}
+    </Formik>
+  );
+};
+
+export default OptionalConfigurationsStep;

package/lib/ocm/components/clusterWizard/disconnected/ReviewStep.tsx

@@ -26,15 +26,18 @@ import {
 } from '@patternfly/react-core';
 import { Formik } from 'formik';
 import { saveAs } from 'file-saver';
-import { useNavigate } from 'react-router-dom-v5-compat';
+import { useNavigate, useParams } from 'react-router-dom-v5-compat';
 
 import { getOperatorSpecs } from '../../../../common/components/operators/operatorSpecs';
-
-const downloadUrl =
-  'https://mirror.openshift.com/pub/cgw/assisted-installer-disconnected/latest/agent-ove.x86_64.iso';
+import ClustersService from '../../../services/ClustersService';
+import { handleApiError, getApiErrorMessage } from '../../../../common/api';
+import { useAlerts } from '../../../../common/components/AlertsContextProvider';
+import { AlertVariant } from '@patternfly/react-core';
 
 const ReviewStep = () => {
-  const { moveBack } = useClusterWizardContext();
+  const { moveBack, disconnectedInfraEnv, setDisconnectedInfraEnv } = useClusterWizardContext();
+  const { clusterId } = useParams<{ clusterId: string }>();
+  const { addAlert } = useAlerts();
   const opSpecs = getOperatorSpecs(() => undefined);
   const navigate = useNavigate();
 
@@ -50,11 +53,40 @@ const ReviewStep = () => {
         footer={
           <ClusterWizardFooter
             onNext={() => {
-              downloadUrl && saveAs(downloadUrl);
-              navigate('/cluster-list');
+              void (async () => {
+                if (disconnectedInfraEnv?.downloadUrl) {
+                  saveAs(disconnectedInfraEnv.downloadUrl);
+                }
+                if (clusterId) {
+                  try {
+                    await ClustersService.remove(clusterId);
+                    // Remove infraEnv from wizard context after successful deregistration
+                    setDisconnectedInfraEnv(undefined);
+                    // Navigate to cluster-list only after successful deregistration
+                    navigate('/cluster-list');
+                  } catch (error) {
+                    handleApiError(error, () => {
+                      addAlert({
+                        title: 'Failed to deregister cluster',
+                        message: getApiErrorMessage(error),
+                        variant: AlertVariant.danger,
+                      });
+                    });
+                    // Error handling: continue with navigation even if deregistration fails
+                    // Still clear the context to avoid stale data
+                    setDisconnectedInfraEnv(undefined);
+                    // Navigate even on error to avoid getting stuck
+                    navigate('/cluster-list');
+                  }
+                } else {
+                  // If there's no cluster to deregister, navigate immediately
+                  navigate('/cluster-list');
+                }
+              })();
             }}
             onBack={moveBack}
             nextButtonText="Download ISO"
+            disconnectedClusterId={clusterId}
           />
         }
       >

package/lib/ocm/components/clusterWizard/index.ts

@@ -2,4 +2,5 @@ export { default as ClusterDetailsForm } from './ClusterDetailsForm';
 export { default as NewClusterWizard } from './NewClusterWizard';
 export { default as ClusterWizard } from './ClusterWizard';
 export { default as ClusterWizardContextProvider } from './ClusterWizardContextProvider';
+export { useClusterWizardContext } from './ClusterWizardContext';
 export { OpenShiftVersionsContextProvider } from './OpenShiftVersionsContext';

package/lib/ocm/components/clusterWizard/wizardTransition.ts

@@ -31,7 +31,8 @@ export type ClusterWizardStepsType =
   | 'custom-manifests'
   | 'credentials-download'
   | 'disconnected-basic'
-  | 'disconnected-review';
+  | 'disconnected-review'
+  | 'disconnected-optional-configurations';
 
 const wizardStepsOrder: ClusterWizardStepsType[] = [
   'cluster-details',
@@ -49,6 +50,7 @@ const wizardStepsOrder: ClusterWizardStepsType[] = [
 
 export const disconnectedSteps: ClusterWizardStepsType[] = [
   'disconnected-basic',
+  'disconnected-optional-configurations',
   'disconnected-review',
 ];
 
@@ -260,6 +262,7 @@ const credentialsValidationMap = buildEmptyValidationsMap();
 const customManifestsValidationsMap = buildEmptyValidationsMap();
 const disconnectedReviewValidationsMap = buildEmptyValidationsMap();
 const disconnectedBasicValidationsMap = buildEmptyValidationsMap();
+const disconnectedOptionalConfigurationsValidationsMap = buildEmptyValidationsMap();
 
 export const wizardStepsValidationsMap: WizardStepsValidationMap<ClusterWizardStepsType> = {
   'cluster-details': clusterDetailsStepValidationsMap,
@@ -275,6 +278,7 @@ export const wizardStepsValidationsMap: WizardStepsValidationMap<ClusterWizardSt
   'credentials-download': credentialsValidationMap,
   'disconnected-review': disconnectedReviewValidationsMap,
   'disconnected-basic': disconnectedBasicValidationsMap,
+  'disconnected-optional-configurations': disconnectedOptionalConfigurationsValidationsMap,
 };
 
 export const allClusterWizardSoftValidationIds =

package/lib/ocm/components/hosts/HostsDiscoveryTable.tsx

@@ -40,9 +40,10 @@ const HostRowDetailExpand = ({ obj: host }: ExpandComponentProps<Host>) => (
 
 type HostsDiscoveryTableProps = {
   cluster: Cluster;
+  hosts: Host[];
 };
 
-const HostsDiscoveryTable = ({ cluster }: HostsDiscoveryTableProps) => {
+const HostsDiscoveryTable = ({ cluster, hosts }: HostsDiscoveryTableProps) => {
   const {
     onEditHost,
     actionChecks,
@@ -55,6 +56,7 @@ const HostsDiscoveryTable = ({ cluster }: HostsDiscoveryTableProps) => {
     onMassDeleteHost,
     ...modalProps
   } = useHostsTable(cluster);
+
   const { wizardPerPage, setWizardPerPage } = useClusterWizardContext();
 
   const { isViewerMode } = useSelector(selectCurrentClusterPermissionsState);
@@ -83,7 +85,6 @@ const HostsDiscoveryTable = ({ cluster }: HostsDiscoveryTableProps) => {
     [t, onEditHost, actionChecks.canEditHostname, actionChecks.canEditRole, onEditRole, cluster],
   );
 
-  const hosts = cluster.hosts || [];
   const paginationProps = usePagination(hosts.length, wizardPerPage, setWizardPerPage);
   const itemIDs = hosts.map((h) => h.id);
   const showBulkActions = !(isViewerMode || isSNOCluster);

package/lib/ocm/hooks/index.ts

@@ -5,4 +5,5 @@ export { default as usePullSecret } from './usePullSecret';
 export { default as useClusterPreflightRequirements } from './useClusterPreflightRequirements';
 export { default as useUISettings } from './useUISettings';
 export { default as useInfraEnv } from './useInfraEnv';
+export { default as useInfraEnvHosts } from './useInfraEnvHosts';
 export { useFeatureDetection } from './use-feature-detection';

package/lib/ocm/hooks/useInfraEnvHosts.ts

@@ -0,0 +1,60 @@
+import React from 'react';
+import useInfraEnvId from './useInfraEnvId';
+import { CpuArchitecture, DEFAULT_POLLING_INTERVAL } from '../../common';
+import { getErrorMessage } from '../../common/utils';
+import { InfraEnvsAPI } from '../services/apis';
+import InfraEnvIdsCacheService from '../services/InfraEnvIdsCacheService';
+import { Cluster, Host } from '@openshift-assisted/types/assisted-installer-service';
+
+const useInfraEnvHosts = (
+  clusterId: Cluster['id'],
+  cpuArchitecture: CpuArchitecture,
+  clusterName?: string,
+  pullSecret?: string,
+  openshiftVersion?: string,
+) => {
+  const [hosts, setHosts] = React.useState<Host[]>();
+  const [error, setError] = React.useState('');
+  const { infraEnvId, error: infraEnvIdError } = useInfraEnvId(
+    clusterId,
+    cpuArchitecture,
+    clusterName,
+    pullSecret,
+    openshiftVersion,
+  );
+
+  const getHosts = React.useCallback(async () => {
+    try {
+      if (infraEnvId) {
+        const { data: hostsData } = await InfraEnvsAPI.getHosts(infraEnvId);
+        setHosts(hostsData);
+      }
+    } catch (e) {
+      // Invalidate this cluster's cached data
+      InfraEnvIdsCacheService.removeInfraEnvId(clusterId, cpuArchitecture);
+      setError(getErrorMessage(e));
+    }
+  }, [clusterId, cpuArchitecture, infraEnvId]);
+
+  React.useEffect(() => {
+    if (infraEnvIdError) {
+      setHosts(undefined);
+      setError(infraEnvIdError);
+    } else {
+      if (infraEnvId) {
+        // Initial fetch
+        void getHosts();
+
+        // Set up polling to refetch hosts periodically
+        const intervalId = setInterval(() => {
+          void getHosts();
+        }, DEFAULT_POLLING_INTERVAL);
+
+        return () => clearInterval(intervalId);
+      }
+    }
+  }, [getHosts, infraEnvId, infraEnvIdError]);
+
+  return { hosts, error, isLoading: !hosts && !error };
+};
+export default useInfraEnvHosts;

package/lib/ocm/hooks/useInfraEnvId.ts

@@ -7,6 +7,7 @@ import {
   InfraEnv,
   InfraEnvCreateParams,
 } from '@openshift-assisted/types/assisted-installer-service';
+import { useFeature } from './use-feature';
 
 export default function useInfraEnvId(
   clusterId: Cluster['id'],
@@ -17,10 +18,15 @@ export default function useInfraEnvId(
 ) {
   const [infraEnvId, setInfraEnv] = React.useState<InfraEnv['id']>();
   const [error, setError] = React.useState('');
+  const isSingleClusterFeatureEnabled = useFeature('ASSISTED_INSTALLER_SINGLE_CLUSTER_FEATURE');
 
   const findInfraEnvId = React.useCallback(async () => {
     try {
-      const infraEnvId = await InfraEnvsService.getInfraEnvId(clusterId, cpuArchitecture);
+      const infraEnvId = await InfraEnvsService.getInfraEnvId(
+        clusterId,
+        cpuArchitecture,
+        isSingleClusterFeatureEnabled,
+      );
       if (infraEnvId && !(infraEnvId instanceof Error)) {
         setInfraEnv(infraEnvId);
       } else {
@@ -39,7 +45,14 @@ export default function useInfraEnvId(
     } catch (e) {
       setError(getErrorMessage(e));
     }
-  }, [clusterId, cpuArchitecture, clusterName, pullSecret, openshiftVersion]);
+  }, [
+    clusterId,
+    cpuArchitecture,
+    isSingleClusterFeatureEnabled,
+    pullSecret,
+    clusterName,
+    openshiftVersion,
+  ]);
 
   React.useEffect(() => {
     if (!clusterId) {

package/lib/ocm/hooks/useLateBinding.ts

@@ -0,0 +1,71 @@
+import { useCallback, useEffect, useState } from 'react';
+import { Cluster } from '@openshift-assisted/types/assisted-installer-service';
+import { CpuArchitecture, useAlerts } from '../../common';
+import useInfraEnvHosts from './useInfraEnvHosts';
+import HostsService from '../services/HostsService';
+import { getErrorMessage } from '../../common/utils';
+import { useFeature } from './use-feature';
+
+const useLateBinding = (cluster: Cluster): boolean => {
+  const [isBinding, setIsBinding] = useState(false);
+  const { addAlert, removeAlert, alerts } = useAlerts();
+  const isSingleClusterFeatureEnabled = useFeature('ASSISTED_INSTALLER_SINGLE_CLUSTER_FEATURE');
+
+  const {
+    hosts: infraEnvHosts,
+    error: infraEnvError,
+    isLoading: infraEnvLoading,
+  } = useInfraEnvHosts(
+    isSingleClusterFeatureEnabled ? cluster.id : '',
+    cluster.cpuArchitecture
+      ? (cluster.cpuArchitecture as CpuArchitecture)
+      : CpuArchitecture.USE_DAY1_ARCHITECTURE,
+    cluster.name,
+    undefined,
+    cluster.openshiftVersion,
+  );
+
+  const bindHosts = useCallback(async () => {
+    if (infraEnvHosts && !infraEnvError && !infraEnvLoading && isSingleClusterFeatureEnabled) {
+      for (const host of infraEnvHosts) {
+        if (host.clusterId !== cluster.id) {
+          setIsBinding(true);
+          try {
+            const alertKey = alerts.find((alert) => alert.key === host.id)?.key;
+            if (alertKey) {
+              removeAlert(alertKey);
+            }
+            await HostsService.bind(host, cluster.id);
+          } catch (error) {
+            addAlert({
+              title: `Failed to bind host ${host.requestedHostname || ''}`,
+              message: getErrorMessage(error),
+              key: host.id,
+            });
+          } finally {
+            setIsBinding(false);
+          }
+        }
+      }
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [
+    infraEnvHosts,
+    infraEnvError,
+    infraEnvLoading,
+    isSingleClusterFeatureEnabled,
+    cluster.id,
+    addAlert,
+    removeAlert,
+  ]);
+
+  useEffect(() => {
+    if (isSingleClusterFeatureEnabled) {
+      void bindHosts();
+    }
+  }, [isSingleClusterFeatureEnabled, bindHosts]);
+
+  return infraEnvLoading || isBinding;
+};
+
+export default useLateBinding;

package/lib/ocm/services/ClustersService.ts

@@ -26,7 +26,11 @@ const ClustersService = {
     return hosts.find((host) => host.id === hostId);
   },
 
-  async create(params: ClusterCreateParamsWithStaticNetworking, isAssistedMigration?: boolean) {
+  async create(
+    params: ClusterCreateParamsWithStaticNetworking,
+    isAssistedMigration?: boolean,
+    isSingleClusterFeatureEnabled?: boolean,
+  ) {
     if (isAssistedMigration) {
       params.tags = AI_ASSISTED_MIGRATION_TAG;
     }
@@ -44,7 +48,9 @@ const ClustersService = {
       infraEnvCreateParams.imageType = 'minimal-iso';
     }
 
-    await InfraEnvsService.create(infraEnvCreateParams);
+    if (!isSingleClusterFeatureEnabled) {
+      await InfraEnvsService.create(infraEnvCreateParams);
+    }
 
     return cluster;
   },
@@ -165,5 +171,11 @@ const ClustersService = {
       this.getUpdateManifestParams(existingManifest, updatedManifest),
     );
   },
+  registerDisconnected(params: { name: string; openshiftVersion: string }) {
+    return ClustersAPI.registerDisconnected({
+      name: params.name,
+      openshiftVersion: params.openshiftVersion,
+    });
+  },
 };
 export default ClustersService;

package/lib/ocm/services/HostsService.ts

@@ -1,4 +1,5 @@
 import {
+  Cluster,
   Disk,
   DiskRole,
   Host,
@@ -84,6 +85,14 @@ const HostsService = {
     return HostsAPI.installHost(host.infraEnvId, host.id);
   },
 
+  bind(host: Host, clusterId: Cluster['id']) {
+    if (!host.infraEnvId) {
+      throw new Error(`Cannot bind host ${host.id}, missing infraEnvId`);
+    }
+
+    return HostsAPI.bindHost(host.infraEnvId, host.id, clusterId);
+  },
+
   installAll(hosts: Host[]) {
     const promises = [];
     for (const host of hosts) {

package/lib/ocm/services/InfraEnvsService.ts

@@ -14,10 +14,13 @@ const InfraEnvsService = {
   async getInfraEnvId(
     clusterId: Cluster['id'],
     cpuArchitecture: CpuArchitecture,
+    isSingleClusterFeatureEnabled?: boolean,
   ): Promise<string | Error> {
     let infraEnvId = InfraEnvCache.getInfraEnvId(clusterId, cpuArchitecture);
     if (infraEnvId instanceof Error) {
-      const { data: infraEnvs } = await InfraEnvsAPI.list(clusterId);
+      const { data: infraEnvs } = await InfraEnvsAPI.list(
+        !isSingleClusterFeatureEnabled ? clusterId : '',
+      );
       if (infraEnvs.length > 0) {
         InfraEnvCache.updateInfraEnvs(clusterId, infraEnvs);
         infraEnvId = InfraEnvCache.getInfraEnvId(clusterId, cpuArchitecture);

package/package.json

@@ -1,7 +1,7 @@
 {
   "dependencies": {
-    "@openshift-assisted/locales": "2.47.4",
-    "@openshift-assisted/types": "2.47.4",
+    "@openshift-assisted/locales": "2.48.0",
+    "@openshift-assisted/types": "2.48.0",
     "@openshift-console/dynamic-plugin-sdk": "0.0.3",
     "@patternfly/patternfly": "6.2.3",
     "@patternfly/react-code-editor": "6.2.2",
@@ -140,5 +140,5 @@
       ]
     }
   },
-  "version": "2.47.4"
+  "version": "2.48.0"
 }