[Actions] Set system actions on Kibana start

x-pack/packages/kbn-elastic-assistant/impl/connectorland/connector_selector/index.tsx

@@ -50,6 +50,7 @@ export const ConnectorSelector: React.FC<Props> = React.memo(
       enabledInLicense: true,
       minimumLicenseRequired: 'platinum',
       supportedFeatureIds: ['general'],
+      isSystemActionType: false,
       id: '.gen-ai',
       name: 'Generative AI',
       enabled: true,

x-pack/packages/kbn-elastic-assistant/impl/connectorland/connector_setup/index.tsx

@@ -92,6 +92,7 @@ export const useConnectorSetup = ({
       actionTypes?.find((at) => at.id === GEN_AI_CONNECTOR_ID) ?? {
         enabledInConfig: true,
         enabledInLicense: true,
+        isSystemActionType: false,
         minimumLicenseRequired: 'platinum',
         supportedFeatureIds: ['general'],
         id: '.gen-ai',

x-pack/plugins/actions/common/types.ts

@@ -22,6 +22,7 @@ export interface ActionType {
   enabledInLicense: boolean;
   minimumLicenseRequired: LicenseType;
   supportedFeatureIds: string[];
+  isSystemActionType: boolean;
 }
 
 export enum InvalidEmailReason {

x-pack/plugins/actions/server/action_type_registry.mock.ts

@@ -17,6 +17,7 @@ const createActionTypeRegistryMock = () => {
     ensureActionTypeEnabled: jest.fn(),
     isActionTypeEnabled: jest.fn(),
     isActionExecutable: jest.fn(),
+    isSystemActionType: jest.fn(),
     getUtils: jest.fn(),
   };
   return mocked;

x-pack/plugins/actions/server/action_type_registry.test.ts

@@ -36,7 +36,7 @@ describe('actionTypeRegistry', () => {
       ),
       actionsConfigUtils: mockedActionsConfig,
       licenseState: mockedLicenseState,
-      preconfiguredActions: [
+      inMemoryConnectors: [
         {
           actionTypeId: 'foo',
           config: {},
@@ -47,6 +47,16 @@ describe('actionTypeRegistry', () => {
           isDeprecated: false,
           isSystemAction: false,
         },
+        {
+          actionTypeId: '.cases',
+          config: {},
+          id: 'system-connector-.cases',
+          name: 'System action: .cases',
+          secrets: {},
+          isPreconfigured: false,
+          isDeprecated: false,
+          isSystemAction: true,
+        },
       ],
     };
   });
@@ -217,7 +227,7 @@ describe('actionTypeRegistry', () => {
       expect(actionTypeRegistryParams.licensing.featureUsage.register).not.toHaveBeenCalled();
     });
 
-    test('does not allows registering system actions', () => {
+    test('allows registering system actions', () => {
       const actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
 
       expect(() =>
@@ -226,15 +236,15 @@ describe('actionTypeRegistry', () => {
           name: 'My action type',
           minimumLicenseRequired: 'basic',
           supportedFeatureIds: ['alerting'],
-          isSystemAction: true,
+          isSystemActionType: true,
           validate: {
             config: { schema: schema.object({}) },
             secrets: { schema: schema.object({}) },
             params: { schema: schema.object({}) },
           },
           executor,
         })
-      ).toThrowErrorMatchingInlineSnapshot(`"System actions are not supported"`);
+      ).not.toThrow();
     });
   });
 
@@ -302,6 +312,7 @@ describe('actionTypeRegistry', () => {
           enabledInLicense: true,
           minimumLicenseRequired: 'basic',
           supportedFeatureIds: ['alerting'],
+          isSystemActionType: false,
         },
       ]);
       expect(mockedActionsConfig.isActionTypeEnabled).toHaveBeenCalled();
@@ -345,11 +356,46 @@ describe('actionTypeRegistry', () => {
           enabledInLicense: true,
           minimumLicenseRequired: 'basic',
           supportedFeatureIds: ['alerting'],
+          isSystemActionType: false,
         },
       ]);
       expect(mockedActionsConfig.isActionTypeEnabled).toHaveBeenCalled();
       expect(mockedLicenseState.isLicenseValidForActionType).toHaveBeenCalled();
     });
+
+    test('sets the isSystemActionType correctly for system actions', () => {
+      mockedLicenseState.isLicenseValidForActionType.mockReturnValue({ isValid: true });
+      const actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
+
+      actionTypeRegistry.register({
+        id: '.cases',
+        name: 'Cases',
+        minimumLicenseRequired: 'platinum',
+        supportedFeatureIds: ['alerting'],
+        validate: {
+          config: { schema: schema.object({}) },
+          secrets: { schema: schema.object({}) },
+          params: { schema: schema.object({}) },
+        },
+        isSystemActionType: true,
+        executor,
+      });
+
+      const actionTypes = actionTypeRegistry.list();
+
+      expect(actionTypes).toEqual([
+        {
+          id: '.cases',
+          name: 'Cases',
+          enabled: true,
+          enabledInConfig: true,
+          enabledInLicense: true,
+          minimumLicenseRequired: 'platinum',
+          supportedFeatureIds: ['alerting'],
+          isSystemActionType: true,
+        },
+      ]);
+    });
   });
 
   describe('has()', () => {
@@ -378,6 +424,7 @@ describe('actionTypeRegistry', () => {
 
   describe('isActionTypeEnabled', () => {
     let actionTypeRegistry: ActionTypeRegistry;
+
     const fooActionType: ActionType = {
       id: 'foo',
       name: 'Foo',
@@ -393,9 +440,17 @@ describe('actionTypeRegistry', () => {
       },
     };
 
+    const systemActionType: ActionType = {
+      ...fooActionType,
+      id: 'system-action-type',
+      name: 'System action type',
+      isSystemActionType: true,
+    };
+
     beforeEach(() => {
       actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
       actionTypeRegistry.register(fooActionType);
+      actionTypeRegistry.register(systemActionType);
     });
 
     test('should call isActionTypeEnabled of the actions config', async () => {
@@ -417,6 +472,15 @@ describe('actionTypeRegistry', () => {
       expect(actionTypeRegistry.isActionExecutable('my-slack1', 'foo')).toEqual(true);
     });
 
+    test('should return true when isActionTypeEnabled is false and isLicenseValidForActionType is true and it has system connectors', async () => {
+      mockedActionsConfig.isActionTypeEnabled.mockReturnValue(false);
+      mockedLicenseState.isLicenseValidForActionType.mockReturnValue({ isValid: true });
+
+      expect(
+        actionTypeRegistry.isActionExecutable('system-connector-.cases', 'system-action-type')
+      ).toEqual(true);
+    });
+
     test('should call isLicenseValidForActionType of the license state with notifyUsage false by default', async () => {
       mockedLicenseState.isLicenseValidForActionType.mockReturnValue({ isValid: true });
       actionTypeRegistry.isActionTypeEnabled('foo');
@@ -567,4 +631,62 @@ describe('actionTypeRegistry', () => {
       expect(result).toEqual(['foo']);
     });
   });
+
+  describe('isSystemActionType()', () => {
+    it('should return true if the action type is a system action type', () => {
+      const registry = new ActionTypeRegistry(actionTypeRegistryParams);
+
+      registry.register({
+        id: '.cases',
+        name: 'Cases',
+        minimumLicenseRequired: 'platinum',
+        supportedFeatureIds: ['alerting'],
+        validate: {
+          config: { schema: schema.object({}) },
+          secrets: { schema: schema.object({}) },
+          params: { schema: schema.object({}) },
+        },
+        isSystemActionType: true,
+        executor,
+      });
+
+      const result = registry.isSystemActionType('.cases');
+      expect(result).toBe(true);
+    });
+
+    it('should return false if the action type is not a system action type', () => {
+      mockedLicenseState.isLicenseValidForActionType.mockReturnValue({ isValid: true });
+
+      const registry = new ActionTypeRegistry(actionTypeRegistryParams);
+
+      registry.register({
+        id: 'foo',
+        name: 'Foo',
+        minimumLicenseRequired: 'basic',
+        supportedFeatureIds: ['alerting'],
+        validate: {
+          config: { schema: schema.object({}) },
+          secrets: { schema: schema.object({}) },
+          params: { schema: schema.object({}) },
+        },
+        executor,
+      });
+
+      const allTypes = registry.getAllTypes();
+      expect(allTypes.length).toBe(1);
+
+      const result = registry.isSystemActionType('foo');
+      expect(result).toBe(false);
+    });
+
+    it('should return false if the action type does not exists', () => {
+      const registry = new ActionTypeRegistry(actionTypeRegistryParams);
+
+      const allTypes = registry.getAllTypes();
+      expect(allTypes.length).toBe(0);
+
+      const result = registry.isSystemActionType('not-exist');
+      expect(result).toBe(false);
+    });
+  });
 });

x-pack/plugins/actions/server/action_type_registry.ts

@@ -14,7 +14,7 @@ import { ActionsConfigurationUtilities } from './actions_config';
 import { getActionTypeFeatureUsageName, TaskRunnerFactory, ILicenseState } from './lib';
 import {
   ActionType,
-  PreConfiguredAction,
+  InMemoryConnector,
   ActionTypeConfig,
   ActionTypeSecrets,
   ActionTypeParams,
@@ -26,7 +26,7 @@ export interface ActionTypeRegistryOpts {
   taskRunnerFactory: TaskRunnerFactory;
   actionsConfigUtils: ActionsConfigurationUtilities;
   licenseState: ILicenseState;
-  preconfiguredActions: PreConfiguredAction[];
+  inMemoryConnectors: InMemoryConnector[];
 }
 
 export class ActionTypeRegistry {
@@ -35,15 +35,15 @@ export class ActionTypeRegistry {
   private readonly taskRunnerFactory: TaskRunnerFactory;
   private readonly actionsConfigUtils: ActionsConfigurationUtilities;
   private readonly licenseState: ILicenseState;
-  private readonly preconfiguredActions: PreConfiguredAction[];
+  private readonly inMemoryConnectors: InMemoryConnector[];
   private readonly licensing: LicensingPluginSetup;
 
   constructor(constructorParams: ActionTypeRegistryOpts) {
     this.taskManager = constructorParams.taskManager;
     this.taskRunnerFactory = constructorParams.taskRunnerFactory;
     this.actionsConfigUtils = constructorParams.actionsConfigUtils;
     this.licenseState = constructorParams.licenseState;
-    this.preconfiguredActions = constructorParams.preconfiguredActions;
+    this.inMemoryConnectors = constructorParams.inMemoryConnectors;
     this.licensing = constructorParams.licensing;
   }
 
@@ -78,7 +78,7 @@ export class ActionTypeRegistry {
   }
 
   /**
-   * Returns true if action type is enabled or it is a preconfigured action type.
+   * Returns true if action type is enabled or it is an in memory action type.
    */
   public isActionExecutable(
     actionId: string,
@@ -89,12 +89,17 @@ export class ActionTypeRegistry {
     return (
       actionTypeEnabled ||
       (!actionTypeEnabled &&
-        this.preconfiguredActions.find(
-          (preconfiguredAction) => preconfiguredAction.id === actionId
-        ) !== undefined)
+        this.inMemoryConnectors.find((inMemoryConnector) => inMemoryConnector.id === actionId) !==
+          undefined)
     );
   }
 
+  /**
+   * Returns true if the action type is a system action type
+   */
+  public isSystemActionType = (actionTypeId: string): boolean =>
+    Boolean(this.actionTypes.get(actionTypeId)?.isSystemActionType);
+
   /**
    * Registers an action type to the action type registry
    */
@@ -104,18 +109,6 @@ export class ActionTypeRegistry {
     Params extends ActionTypeParams = ActionTypeParams,
     ExecutorResultData = void
   >(actionType: ActionType<Config, Secrets, Params, ExecutorResultData>) {
-    // TODO: Remove when system action are supported
-    if (actionType.isSystemAction) {
-      throw new Error(
-        i18n.translate(
-          'xpack.actions.actionTypeRegistry.register.systemActionsNotSupportedErrorMessage',
-          {
-            defaultMessage: 'System actions are not supported',
-          }
-        )
-      );
-    }
-
     if (this.has(actionType.id)) {
       throw new Error(
         i18n.translate(
@@ -214,6 +207,7 @@ export class ActionTypeRegistry {
         enabledInConfig: this.actionsConfigUtils.isActionTypeEnabled(actionTypeId),
         enabledInLicense: !!this.licenseState.isLicenseValidForActionType(actionType).isValid,
         supportedFeatureIds: actionType.supportedFeatureIds,
+        isSystemActionType: !!actionType.isSystemActionType,
       }));
   }
 

x-pack/plugins/actions/server/actions_client.mock.ts

@@ -27,6 +27,7 @@ const createActionsClientMock = () => {
     listTypes: jest.fn(),
     isActionTypeEnabled: jest.fn(),
     isPreconfigured: jest.fn(),
+    isSystemAction: jest.fn(),
     getGlobalExecutionKpiWithAuth: jest.fn(),
     getGlobalExecutionLogWithAuth: jest.fn(),
   };