[UII] Restrict agentless integrations to deployments with agentless enabled

x-pack/plugins/fleet/common/services/agentless_helper.test.ts

@@ -0,0 +1,275 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import type { RegistryPolicyTemplate } from '../types';
+
+import {
+  isAgentlessIntegration,
+  getAgentlessAgentPolicyNameFromPackagePolicyName,
+  isOnlyAgentlessIntegration,
+  isOnlyAgentlessPolicyTemplate,
+} from './agentless_helper';
+
+describe('agentless_helper', () => {
+  describe('isAgentlessIntegration', () => {
+    it('should return true if packageInfo is defined and has at least one agentless integration', () => {
+      const packageInfo = {
+        policy_templates: [
+          {
+            name: 'template1',
+            title: 'Template 1',
+            description: '',
+            deployment_modes: {
+              default: {
+                enabled: true,
+              },
+              agentless: {
+                enabled: true,
+              },
+            },
+          },
+          {
+            name: 'template2',
+            title: 'Template 2',
+            description: '',
+            deployment_modes: {
+              default: {
+                enabled: true,
+              },
+            },
+          },
+        ] as RegistryPolicyTemplate[],
+      };
+
+      const result = isAgentlessIntegration(packageInfo);
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false if packageInfo is defined but does not have agentless integrations', () => {
+      const packageInfo = {
+        policy_templates: [
+          {
+            name: 'template1',
+            title: 'Template 1',
+            description: '',
+            deployment_modes: {
+              default: {
+                enabled: true,
+              },
+              agentless: {
+                enabled: false,
+              },
+            },
+          },
+          {
+            name: 'template2',
+            title: 'Template 2',
+            description: '',
+            deployment_modes: {
+              default: {
+                enabled: false,
+              },
+              agentless: {
+                enabled: false,
+              },
+            },
+          },
+        ] as RegistryPolicyTemplate[],
+      };
+
+      const result = isAgentlessIntegration(packageInfo);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false if packageInfo has no policy templates', () => {
+      const packageInfo = {
+        policy_templates: [],
+      };
+
+      const result = isAgentlessIntegration(packageInfo);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false if packageInfo is undefined', () => {
+      const packageInfo = undefined;
+
+      const result = isAgentlessIntegration(packageInfo);
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('getAgentlessAgentPolicyNameFromPackagePolicyName', () => {
+    it('should return the agentless agent policy name based on the package policy name', () => {
+      const packagePolicyName = 'example-package-policy';
+
+      const result = getAgentlessAgentPolicyNameFromPackagePolicyName(packagePolicyName);
+
+      expect(result).toBe('Agentless policy for example-package-policy');
+    });
+  });
+
+  describe('isOnlyAgentlessIntegration', () => {
+    it('should return true if packageInfo is defined and has only agentless integration', () => {
+      const packageInfo = {
+        policy_templates: [
+          {
+            name: 'template1',
+            title: 'Template 1',
+            description: '',
+            deployment_modes: {
+              default: {
+                enabled: false,
+              },
+              agentless: {
+                enabled: true,
+              },
+            },
+          },
+          {
+            name: 'template2',
+            title: 'Template 2',
+            description: '',
+            deployment_modes: {
+              agentless: {
+                enabled: true,
+              },
+            },
+          },
+        ] as RegistryPolicyTemplate[],
+      };
+
+      const result = isOnlyAgentlessIntegration(packageInfo);
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false if packageInfo is defined but has other deployment types', () => {
+      const packageInfo = {
+        policy_templates: [
+          {
+            name: 'template1',
+            title: 'Template 1',
+            description: '',
+            deployment_modes: {
+              default: {
+                enabled: true,
+              },
+              agentless: {
+                enabled: true,
+              },
+            },
+          },
+          {
+            name: 'template2',
+            title: 'Template 2',
+            description: '',
+            deployment_modes: {
+              default: {
+                enabled: true,
+              },
+            },
+          },
+        ] as RegistryPolicyTemplate[],
+      };
+
+      const result = isOnlyAgentlessIntegration(packageInfo);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false if packageInfo has no policy templates', () => {
+      const packageInfo = {
+        policy_templates: [],
+      };
+
+      const result = isOnlyAgentlessIntegration(packageInfo);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false if packageInfo is undefined', () => {
+      const packageInfo = undefined;
+
+      const result = isOnlyAgentlessIntegration(packageInfo);
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('isOnlyAgentlessPolicyTemplate', () => {
+    it('should return true if the policy template is only agentless', () => {
+      const policyTemplate = {
+        name: 'template1',
+        title: 'Template 1',
+        description: '',
+        deployment_modes: {
+          default: {
+            enabled: false,
+          },
+          agentless: {
+            enabled: true,
+          },
+        },
+      };
+      const policyTemplate2 = {
+        name: 'template2',
+        title: 'Template 2',
+        description: '',
+        deployment_modes: {
+          agentless: {
+            enabled: true,
+          },
+        },
+      };
+
+      const result = isOnlyAgentlessPolicyTemplate(policyTemplate);
+      const result2 = isOnlyAgentlessPolicyTemplate(policyTemplate2);
+
+      expect(result).toBe(true);
+      expect(result2).toBe(true);
+    });
+
+    it('should return false if the policy template has other deployment types', () => {
+      const policyTemplate = {
+        name: 'template1',
+        title: 'Template 1',
+        description: '',
+        deployment_modes: {
+          default: {
+            enabled: true,
+          },
+          agentless: {
+            enabled: true,
+          },
+        },
+      };
+      const policyTemplate2 = {
+        name: 'template2',
+        title: 'Template 2',
+        description: '',
+        deployment_modes: {
+          default: {
+            enabled: true,
+          },
+          agentless: {
+            enabled: false,
+          },
+        },
+      };
+
+      const result = isOnlyAgentlessPolicyTemplate(policyTemplate);
+      const result2 = isOnlyAgentlessPolicyTemplate(policyTemplate2);
+
+      expect(result).toBe(false);
+      expect(result2).toBe(false);
+    });
+  });
+});

x-pack/plugins/fleet/common/services/agentless_helper.ts

@@ -0,0 +1,52 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import type { PackageInfo, RegistryPolicyTemplate } from '../types';
+
+export const isAgentlessIntegration = (
+  packageInfo: Pick<PackageInfo, 'policy_templates'> | undefined
+) => {
+  if (
+    packageInfo?.policy_templates &&
+    packageInfo?.policy_templates.length > 0 &&
+    !!packageInfo?.policy_templates.find(
+      (policyTemplate) => policyTemplate?.deployment_modes?.agentless.enabled === true
+    )
+  ) {
+    return true;
+  }
+  return false;
+};
+
+export const getAgentlessAgentPolicyNameFromPackagePolicyName = (packagePolicyName: string) => {
+  return `Agentless policy for ${packagePolicyName}`;
+};
+
+export const isOnlyAgentlessIntegration = (
+  packageInfo: Pick<PackageInfo, 'policy_templates'> | undefined
+) => {
+  if (
+    packageInfo?.policy_templates &&
+    packageInfo?.policy_templates.length > 0 &&
+    packageInfo?.policy_templates.every((policyTemplate) =>
+      isOnlyAgentlessPolicyTemplate(policyTemplate)
+    )
+  ) {
+    return true;
+  }
+  return false;
+};
+
+export const isOnlyAgentlessPolicyTemplate = (policyTemplate: {
+  deployment_modes?: RegistryPolicyTemplate['deployment_modes'];
+}) => {
+  return (
+    policyTemplate.deployment_modes?.agentless.enabled === true &&
+    (!policyTemplate.deployment_modes?.default ||
+      policyTemplate.deployment_modes?.default.enabled === false)
+  );
+};

x-pack/plugins/fleet/public/applications/fleet/sections/agent_policy/create_package_policy_page/components/steps/components/package_policy_input_panel.tsx

@@ -31,7 +31,7 @@ import type {
 } from '../../../../../../types';
 import type { PackagePolicyInputValidationResults } from '../../../services';
 import { hasInvalidButRequiredVar, countValidationErrors } from '../../../services';
-import { useAgentless } from '../../../single_page_layout/hooks/setup_technology';
+import { useAgentless } from '../../../../../../hooks';
 
 import { PackagePolicyInputConfig } from './package_policy_input_config';
 import { PackagePolicyInputStreamConfig } from './package_policy_input_stream';

x-pack/plugins/fleet/public/applications/fleet/sections/agent_policy/create_package_policy_page/single_page_layout/components/layout.tsx

@@ -19,8 +19,7 @@ import {
   EuiSpacer,
 } from '@elastic/eui';
 
-import { useAgentless } from '../hooks/setup_technology';
-
+import { useAgentless } from '../../../../../hooks';
 import { WithHeaderLayout } from '../../../../../layouts';
 import type { AgentPolicy, PackageInfo, RegistryPolicyTemplate } from '../../../../../types';
 import { PackageIcon } from '../../../../../components';

x-pack/plugins/fleet/public/applications/fleet/sections/agent_policy/create_package_policy_page/single_page_layout/hooks/form.tsx

@@ -27,6 +27,7 @@ import {
   sendBulkInstallPackages,
   sendGetPackagePolicies,
   useMultipleAgentPolicies,
+  useAgentless,
 } from '../../../../../hooks';
 import { isVerificationError, packageToPackagePolicy } from '../../../../../services';
 import {
@@ -49,8 +50,6 @@ import {
   getCloudShellUrlFromPackagePolicy,
 } from '../../../../../../../components/cloud_security_posture/services';
 
-import { useAgentless } from './setup_technology';
-
 export async function createAgentPolicy({
   packagePolicy,
   newAgentPolicy,