Wazuh Core Plugin API

export class WazuhCorePlugin
  implements Plugin<WazuhCorePluginSetup, WazuhCorePluginStart>

public async setup(core: CoreSetup): Promise<WazuhCorePluginSetup>

export class MyPlugin implements Plugin {
  public setup(core: CoreSetup, plugins: { wazuhCore: WazuhCorePluginSetup }) {
    // Access configuration
    const config = plugins.wazuhCore.configuration;
    
    // Use dashboard security
    const security = plugins.wazuhCore.dashboardSecurity;
    
    // Use utilities
    const formatted = plugins.wazuhCore.utils.formatUIDate(new Date());
  }
}

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

get<T = any>(settingKey: string): Promise<T>

import { getWazuhCorePlugin } from './plugin-services';

const wazuhCore = getWazuhCorePlugin();

// Get index pattern
const pattern = await wazuhCore.configuration.get('pattern');
// => "wazuh-alerts-*"

// Get timeout setting
const timeout = await wazuhCore.configuration.get('timeout');
// => 20000

set(settingKey: string, value: any): Promise<void>

// Update timeout
await wazuhCore.configuration.set('timeout', 30000);

// Update index pattern
await wazuhCore.configuration.set('pattern', 'wazuh-alerts-4.x-*');

fetchCurrentPlatform(): Promise<string>

const platform = await wazuhCore.dashboardSecurity.fetchCurrentPlatform();

if (platform === 'opensearch') {
  // OpenSearch Security is active
} else if (platform === 'xpack') {
  // Elastic X-Pack security is active
}

fetchCurrentUser(): Promise<{
  username: string,
  authContext: any
}>

const user = await wazuhCore.dashboardSecurity.fetchCurrentUser();
console.log(`Logged in as: ${user.username}`);

fetchCurrentUserRoles(): Promise<string[]>

const roles = await wazuhCore.dashboardSecurity.fetchCurrentUserRoles();

if (roles.includes('administrator')) {
  // User has admin privileges
}

hasDashboardSecurity(): Promise<boolean>

const hasecurity = await wazuhCore.dashboardSecurity.hasDashboardSecurity();

if (!hasSecurity) {
  // Show security warning
}

public async setup(
  core: CoreSetup,
  plugins: PluginSetup
): Promise<WazuhCorePluginSetup>

request(
  method: string,
  path: string,
  data: any,
  options: { apiHostID: string; forceRefresh?: boolean }
): Promise<any>

// In a route handler
router.get(
  { path: '/api/agents/summary', validate: false },
  async (context, request, response) => {
    try {
      const result = await context.wazuh_core.api.client.asCurrentUser.request(
        'GET',
        '/agents/summary/status',
        {},
        { apiHostID: 'default' }
      );
      
      return response.ok({ body: result });
    } catch (error) {
      return response.customError({
        statusCode: error.statusCode || 500,
        body: { message: error.message }
      });
    }
  }
);

authenticate(apiHostID: string): Promise<string>

const token = await context.wazuh_core.api.client.asCurrentUser.authenticate('default');

declare module 'opensearch_dashboards/server' {
  interface RequestHandlerContext {
    wazuh_core: {
      configuration: IConfigurationEnhanced;
      dashboardSecurity: ISecurityFactory;
      manageHosts: ManageHosts;
      serverAPIClient: ServerAPIClient;
      api: {
        client: {
          asInternalUser: ServerAPIInternalUserClient;
          asCurrentUser: ServerAPIScopedUserClient;
        };
      };
    };
  }
}

router.get(
  { path: '/my-endpoint', validate: false },
  async (context, request, response) => {
    // Access Core services via context
    const config = context.wazuh_core.configuration;
    const security = context.wazuh_core.dashboardSecurity;
    const api = context.wazuh_core.api.client.asCurrentUser;
    
    // Make API request
    const agents = await api.request(
      'GET',
      '/agents',
      {},
      { apiHostID: 'default' }
    );
    
    return response.ok({ body: agents });
  }
);

formatUIDate(date: Date): string

import { getWazuhCorePlugin } from './plugin-services';

const formatted = getWazuhCorePlugin().utils.formatUIDate(new Date());
// => "2026-03-04 10:30:45"

function useDockedSideNav(): boolean

import React from 'react';
import { getWazuhCorePlugin } from './plugin-services';

function MyComponent() {
  const { useDockedSideNav } = getWazuhCorePlugin().hooks;
  const isDocked = useDockedSideNav();
  
  return (
    <div className={isDocked ? 'with-docked-nav' : 'without-docked-nav'}>
      Content
    </div>
  );
}

export const API_USER_STATUS_RUN_AS = {
  ALL_DISABLED: 0,
  USER_NOT_ALLOWED: 1,
  HOST_DISABLED: 2,
  ENABLED: 3,
} as const;

import { API_USER_STATUS_RUN_AS } from 'plugins/wazuh-core/public';

if (status === API_USER_STATUS_RUN_AS.ENABLED) {
  // run_as is enabled
}