Plugin System

public async setup(core: CoreSetup): Promise<WazuhCorePluginSetup> {
  // Initialize configuration store
  this._internal.configurationStore = new ConfigurationStore(logger);

  // Register configuration providers
  this._internal.configurationStore.registerProvider(
    EConfigurationProviders.INITIALIZER_CONTEXT,
    new InitializerConfigProvider(this.initializerContext)
  );

  this._internal.configurationStore.registerProvider(
    EConfigurationProviders.PLUGIN_UI_SETTINGS,
    new UISettingsConfigProvider(core.uiSettings)
  );

  // Create configuration facade
  this.services.configuration = new Configuration(
    logger,
    this._internal.configurationStore
  );

  // Create dashboard security service
  this.services.dashboardSecurity = new DashboardSecurity(logger, core.http);
  await this.services.dashboardSecurity.setup();

  return {
    ...this.services,
    utils,
    API_USER_STATUS_RUN_AS,
    SettingsValidator,
  };
}

public async start(core: CoreStart): Promise<WazuhCorePluginStart> {
  // Set global service references
  setChrome(core.chrome);
  setCore(core);
  setUiSettings(core.uiSettings);

  // Start configuration service
  await this.services.configuration.start({ http: core.http });

  return {
    ...this.services,
    utils,
    API_USER_STATUS_RUN_AS,
    hooks,
    SettingsValidator,
  };
}

public async setup(core: CoreSetup, plugins: PluginSetup) {
  // Register UI settings for advanced configuration
  const uiSettingsDefs = getUiSettingsDefinitions(PLUGIN_SETTINGS);
  core.uiSettings.register(uiSettingsDefs);

  // Initialize services
  this.services.dashboardSecurity = createDashboardSecurity(plugins);
  this.services.configuration = new Configuration(
    this.logger.get('configuration'),
    this._internal.configurationStore
  );
  this.services.manageHosts = new ManageHosts(
    this.logger.get('manage-hosts'),
    this.services.configuration
  );
  this.services.serverAPIClient = new ServerAPIClient(
    this.logger.get('server-api-client'),
    this.services.manageHosts,
    this.services.dashboardSecurity
  );

  // Register context for route handlers
  core.http.registerRouteHandlerContext('wazuh_core', (context, request) => ({
    ...this.services,
    api: {
      client: {
        asInternalUser: this.services.serverAPIClient.asInternalUser,
        asCurrentUser: this.services.serverAPIClient.asScoped(context, request),
      },
    },
  }));

  return { ...this.services, API_USER_STATUS_RUN_AS, api: {...} };
}

public async start(core: CoreStart): Promise<WazuhCorePluginStart> {
  setCore(core);

  // Start services
  await this.services.configuration.start();
  await this.services.manageHosts.start();

  return {
    ...this.services,
    API_USER_STATUS_RUN_AS,
    api: {...}
  };
}

public async setup(core: CoreSetup, plugins: WazuhSetupPlugins) {
  // Register query languages for search bar
  const languageService = plugins.data.query.queryString.languageService;
  SUPPORTED_LANGUAGES_ARRAY.forEach(language => {
    const languageInstance = languageService.getLanguage(language);
    languageService.registerLanguage({
      ...languageInstance,
      supportedAppNames: [...languageInstance.supportedAppNames, ...appIds],
    });
  });

  // Register all applications
  for (const app of Applications) {
    const { category, id, title, redirectTo, order } = app;

    core.application.register({
      id,
      title,
      order,
      mount: async (params: AppMountParameters) => {
        setWzCurrentAppID(id);
        setWzMainParams(redirectTo());
        initializeInterceptor(core);

        if (this.hideTelemetryBanner) {
          await this.hideTelemetryBanner();
        }

        setScopedHistory(params.history);
        setHeaderActionMenuMounter(params.setHeaderActionMenu);
        NavigationService.getInstance(createHashHistory());

        // Lazy load application bundle
        const { renderApp } = await import('./application');

        setErrorOrchestrator(ErrorOrchestratorService);
        setHttp(core.http);
        setCookies(new Cookies());

        params.element.classList.add('dscAppWrapper', 'wz-app');
        const unmount = await renderApp(params);

        return () => {
          unmount();
          unregisterInterceptor();
        };
      },
      category: Categories.find(({ id: categoryID }) => categoryID === category),
    });
  }

  // Register navigation links for new home page
  registerWazuhNavLinks(
    core.chrome.navGroup.addNavLinksToGroup.bind(core.chrome.navGroup),
    core.chrome.navGroup.getNavGroupEnabled()
  );

  return {};
}

public start(core: CoreStart, plugins: AppPluginStartDependencies): WazuhStart {
  // Hide security alerts
  if (plugins.securityOss) {
    plugins.securityOss.insecureCluster.hideAlert(true);
  }

  // Set telemetry banner hide method
  if (plugins?.telemetry?.telemetryNotifications?.setOptedInNoticeSeen) {
    this.hideTelemetryBanner = () =>
      plugins.telemetry.telemetryNotifications.setOptedInNoticeSeen();
  }

  // Set global service references
  setCore(core);
  setPlugins(plugins);
  setHttp(core.http);
  setToasts(core.notifications.toasts);
  setDataPlugin(plugins.data);
  setUiSettings(core.uiSettings);
  setChrome(core.chrome);
  setNavigationPlugin(plugins.navigation);
  setVisualizationsPlugin(plugins.visualizations);
  setSavedObjects(core.savedObjects);
  setOverlays(core.overlays);
  setErrorOrchestrator(ErrorOrchestratorService);
  setWazuhCheckUpdatesPlugin(plugins.wazuhCheckUpdates);
  setWazuhCorePlugin(plugins.wazuhCore);

  return {};
}

public async setup(core: CoreSetup, plugins: PluginSetup) {
  // Register custom route handler context
  core.http.registerRouteHandlerContext('wazuh', (context, request) => ({
    logger: this.logger.get(
      `${request.route.method.toUpperCase()} ${request.route.path}`
    ),
    server: { info: serverInfo },
    plugins,
    security: plugins.wazuhCore.dashboardSecurity,
    api: context.wazuh_core.api,
  }));

  // Add security headers
  core.http.registerOnPreResponse((request, response, toolkit) => {
    const additionalHeaders = {
      'x-frame-options': 'sameorigin',
    };
    return toolkit.next({ headers: additionalHeaders });
  });

  // Create router and register routes
  const router = core.http.createRouter();
  setupRoutes(router, plugins.wazuhCore);

  // Register health checks (shown in next section)
  // ...

  return {};
}

public async start(core: CoreStart, plugins: any) {
  const globalConfiguration: SharedGlobalConfig =
    await this.initializerContext.config.legacy.globalConfig$
      .pipe(first())
      .toPromise();

  const contextServer = {
    config: globalConfiguration,
  };

  // Start initialization job
  jobInitializeRun({
    core,
    wazuh: {
      logger: this.logger.get('initialize'),
      api: plugins.wazuhCore.api,
    },
    wazuh_core: plugins.wazuhCore,
    server: contextServer,
  });

  // Start queue processing job
  jobQueueRun({
    core,
    wazuh: {
      logger: this.logger.get('queue'),
      api: plugins.wazuhCore.api,
    },
    wazuh_core: plugins.wazuhCore,
    server: contextServer,
  });

  return {};
}