@camunda/ccma-saas-frontend 0.0.31

package/lib/esm/modals/c4-create-console-api-client-modal-handle.d.ts

@@ -0,0 +1,3 @@
+import type { C4CreateConsoleApiClientModalHandle, C4CreateConsoleApiClientModalOpenParams } from '../components/c4-create-console-api-client-modal/c4-create-console-api-client-modal.types';
+export declare function setC4CreateConsoleApiClientModalHandle(next: C4CreateConsoleApiClientModalHandle | undefined): void;
+export declare function openC4CreateConsoleApiClientModal(params: C4CreateConsoleApiClientModalOpenParams): void;

package/lib/esm/modals/c4-create-console-api-client-modal-handle.js

@@ -0,0 +1,12 @@
+/*
+ * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH
+ * under one or more contributor license agreements. Licensed under a commercial license.
+ * You may not use this file except in compliance with the commercial license.
+ */
+let handle;
+export function setC4CreateConsoleApiClientModalHandle(next) {
+    handle = next;
+}
+export function openC4CreateConsoleApiClientModal(params) {
+    handle?.open(params);
+}

package/lib/esm/modals/c4-invite-user-to-organization-modal-handle.d.ts

@@ -0,0 +1,3 @@
+import type { C4InviteUserToOrganizationModalHandle, C4InviteUserToOrganizationModalOpenParams } from '../components/c4-invite-user-to-organization-modal/c4-invite-user-to-organization-modal.types';
+export declare function setC4InviteUserToOrganizationModalHandle(handle: C4InviteUserToOrganizationModalHandle | undefined): void;
+export declare function openC4InviteUserToOrganizationModal(params: C4InviteUserToOrganizationModalOpenParams): void;

package/lib/esm/modals/c4-invite-user-to-organization-modal-handle.js

@@ -0,0 +1,12 @@
+/*
+ * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH
+ * under one or more contributor license agreements. Licensed under a commercial license.
+ * You may not use this file except in compliance with the commercial license.
+ */
+let inviteModalHandle;
+export function setC4InviteUserToOrganizationModalHandle(handle) {
+    inviteModalHandle = handle;
+}
+export function openC4InviteUserToOrganizationModal(params) {
+    inviteModalHandle?.open(params);
+}

package/lib/esm/modals/c4-rename-organization-modal-handle.d.ts

@@ -0,0 +1,3 @@
+import type { C4RenameOrganizationModalHandle, C4RenameOrganizationModalOpenParams } from '../components/c4-rename-organization-modal/c4-rename-organization-modal.types';
+export declare function setC4RenameOrganizationModalHandle(next: C4RenameOrganizationModalHandle | undefined): void;
+export declare function openC4RenameOrganizationModal(params: C4RenameOrganizationModalOpenParams): void;

package/lib/esm/modals/c4-rename-organization-modal-handle.js

@@ -0,0 +1,12 @@
+/*
+ * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH
+ * under one or more contributor license agreements. Licensed under a commercial license.
+ * You may not use this file except in compliance with the commercial license.
+ */
+let handle;
+export function setC4RenameOrganizationModalHandle(next) {
+    handle = next;
+}
+export function openC4RenameOrganizationModal(params) {
+    handle?.open(params);
+}

package/lib/esm/notifications/c4-console-notifications-handle.d.ts

@@ -0,0 +1,8 @@
+import type { AddC4ConsoleNotificationOptions } from '../runtime/c4-console-notifications-context.types';
+export interface C4ConsoleNotificationsHandle {
+    add: (options: AddC4ConsoleNotificationOptions) => string;
+    removeById: (id: string) => void;
+}
+export declare const setC4ConsoleNotificationsHandle: (next: C4ConsoleNotificationsHandle | undefined) => void;
+export declare const addC4ConsoleNotification: (options: AddC4ConsoleNotificationOptions) => string | undefined;
+export declare const removeC4ConsoleNotificationById: (id: string) => void;

package/lib/esm/notifications/c4-console-notifications-handle.js

@@ -0,0 +1,15 @@
+/*
+ * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH
+ * under one or more contributor license agreements. Licensed under a commercial license.
+ * You may not use this file except in compliance with the commercial license.
+ */
+let handle;
+export const setC4ConsoleNotificationsHandle = (next) => {
+    handle = next;
+};
+export const addC4ConsoleNotification = (options) => {
+    return handle?.add(options);
+};
+export const removeC4ConsoleNotificationById = (id) => {
+    handle?.removeById(id);
+};

package/lib/esm/runtime/c4-console-authz.d.ts

@@ -0,0 +1,31 @@
+import { type AccountsPermissions, ConsolePermissions } from '@camunda/ccma-shared-types';
+export interface C4ConsoleAuthzFeatures {
+    console: ConsolePermissions.Features;
+    accounts?: AccountsPermissions.Features;
+}
+export interface C4ConsoleVisibilities {
+    clusters?: {
+        canCreate?: boolean;
+        canEdit?: boolean;
+        canDelete?: boolean;
+        canUpdateTag?: boolean;
+        canWake?: boolean;
+        canSeeClusterLoad?: boolean;
+    };
+}
+export interface C4ConsoleAuthzState {
+    tokenPermissions: string[];
+    orgRoles: string[];
+    features: C4ConsoleAuthzFeatures;
+    visibilities: C4ConsoleVisibilities;
+    isLoading: boolean;
+    error?: unknown;
+}
+export interface DeriveConsoleAuthzParams {
+    accessToken: string;
+    orgId: string;
+}
+export declare function deriveConsoleAuthzFromAccessToken(params: DeriveConsoleAuthzParams): Omit<C4ConsoleAuthzState, 'isLoading' | 'error'>;
+export declare const useC4ConsoleAuthz: (params: {
+    orgId: string;
+}) => C4ConsoleAuthzState;

package/lib/esm/runtime/c4-console-authz.js

@@ -0,0 +1,191 @@
+/*
+ * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH
+ * under one or more contributor license agreements. Licensed under a commercial license.
+ * You may not use this file except in compliance with the commercial license.
+ */
+import { accountsUserFeaturesFromPermissions, ConsolePermissions, consoleUserFeaturesFromPermissions, OrganizationRole, } from '@camunda/ccma-shared-types';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { useC4ConsoleRuntime } from './c4-console-runtime-context.js';
+const AUTH0_BASE_CLAIM = 'https://camunda.com';
+const AUTH0_TOKEN_ATTRIBUTE_ORGS = 'orgs';
+function base64UrlDecodeToString(input) {
+    const padded = input
+        .replace(/-/g, '+')
+        .replace(/_/g, '/')
+        .padEnd(Math.ceil(input.length / 4) * 4, '=');
+    return atob(padded);
+}
+function tryDecodeJwtPayload(accessToken) {
+    const parts = accessToken.split('.');
+    if (parts.length < 2) {
+        return undefined;
+    }
+    try {
+        const json = base64UrlDecodeToString(parts[1] ?? '');
+        const parsed = JSON.parse(json);
+        if (!parsed || typeof parsed !== 'object') {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function stringArrayFromUnknown(input) {
+    if (!Array.isArray(input)) {
+        return [];
+    }
+    return input.filter((item) => typeof item === 'string');
+}
+function orgMembershipsFromUnknown(input) {
+    if (!Array.isArray(input)) {
+        return [];
+    }
+    return input
+        .map((item) => {
+        if (!item || typeof item !== 'object') {
+            return undefined;
+        }
+        const maybe = item;
+        if (typeof maybe.id !== 'string') {
+            return undefined;
+        }
+        return {
+            id: maybe.id,
+            roles: stringArrayFromUnknown(maybe.roles),
+        };
+    })
+        .filter((item) => Boolean(item));
+}
+function hashString(input) {
+    let hash = 5381;
+    for (let i = 0; i < input.length; i += 1) {
+        hash = (hash * 33) ^ input.charCodeAt(i);
+    }
+    return (hash >>> 0).toString(36);
+}
+export function deriveConsoleAuthzFromAccessToken(params) {
+    const payload = tryDecodeJwtPayload(params.accessToken);
+    const tokenPermissions = stringArrayFromUnknown(payload?.permissions);
+    const orgsKey = `${AUTH0_BASE_CLAIM}/${AUTH0_TOKEN_ATTRIBUTE_ORGS}`;
+    const orgMemberships = orgMembershipsFromUnknown(payload?.[orgsKey]);
+    const orgRoles = orgMemberships.find((membership) => membership.id === params.orgId)
+        ?.roles ?? [];
+    const features = {
+        console: consoleUserFeaturesFromPermissions(tokenPermissions),
+        accounts: accountsUserFeaturesFromPermissions(tokenPermissions),
+    };
+    const orgAdminRoles = new Set([
+        OrganizationRole.ADMIN,
+        OrganizationRole.OWNER,
+        OrganizationRole.ORGANIZATION_ADMIN,
+        OrganizationRole.ORGANIZATION_OWNER,
+    ]);
+    const isOrgAdmin = orgRoles.some((role) => orgAdminRoles.has(role));
+    const clusters = features.console.clusters;
+    const visibilities = {
+        clusters: {
+            canCreate: isOrgAdmin || clusters.createOnBehalf,
+            canDelete: isOrgAdmin || clusters.canDeleteAllClusters,
+            canWake: clusters.canSendToSleep,
+            canEdit: isOrgAdmin ||
+                clusters.canMoveToOtherOrg ||
+                clusters.canOverrideEnvVars ||
+                clusters.canUpdateClusterPlanType ||
+                clusters.canUpgradeGeneration ||
+                clusters.canUpgradeGenerationYolo,
+            canUpdateTag: isOrgAdmin ||
+                clusters.canMoveToOtherOrg ||
+                clusters.canUpdateClusterPlanType ||
+                clusters.canOverrideEnvVars,
+            canSeeClusterLoad: clusters.canReadAllClusterInfo,
+        },
+    };
+    return {
+        tokenPermissions,
+        orgRoles,
+        features,
+        visibilities,
+    };
+}
+const authzCache = new Map();
+export const useC4ConsoleAuthz = (params) => {
+    const runtime = useC4ConsoleRuntime();
+    const hasResolvedOnceRef = useRef(false);
+    const [state, setState] = useState(() => ({
+        tokenPermissions: [],
+        orgRoles: [],
+        features: {
+            console: ConsolePermissions.createEmptyFeatures(),
+            accounts: undefined,
+        },
+        visibilities: {},
+        isLoading: true,
+        error: undefined,
+    }));
+    const orgId = params.orgId;
+    const cacheKeyPrefix = useMemo(() => {
+        return `org:${orgId}:stage:${runtime.stage}`;
+    }, [orgId, runtime.stage]);
+    useEffect(() => {
+        let isCancelled = false;
+        async function run() {
+            // Avoid toggling back to a global loading state once we've already
+            // resolved permissions at least once. This prevents UI churn and
+            // repeated tab initialization when runtime/auth identities change.
+            if (!hasResolvedOnceRef.current) {
+                setState((previous) => ({
+                    ...previous,
+                    isLoading: true,
+                    error: undefined,
+                }));
+            }
+            else {
+                setState((previous) => ({
+                    ...previous,
+                    error: undefined,
+                }));
+            }
+            try {
+                const accessToken = await runtime.auth.getAccessToken();
+                const cacheKey = `${cacheKeyPrefix}:token:${hashString(accessToken)}`;
+                const cached = authzCache.get(cacheKey);
+                if (cached) {
+                    if (!isCancelled) {
+                        setState(cached);
+                    }
+                    return;
+                }
+                const derived = deriveConsoleAuthzFromAccessToken({
+                    accessToken,
+                    orgId,
+                });
+                const resolved = {
+                    ...derived,
+                    isLoading: false,
+                    error: undefined,
+                };
+                authzCache.set(cacheKey, resolved);
+                if (!isCancelled) {
+                    setState(resolved);
+                }
+                hasResolvedOnceRef.current = true;
+            }
+            catch (error) {
+                if (!isCancelled) {
+                    setState((previous) => ({
+                        ...previous,
+                        isLoading: false,
+                        error,
+                    }));
+                }
+            }
+        }
+        run();
+        return () => {
+            isCancelled = true;
+        };
+    }, [cacheKeyPrefix, orgId, runtime.auth]);
+    return state;
+};

package/lib/esm/runtime/c4-console-authz.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/esm/runtime/c4-console-authz.spec.js

@@ -0,0 +1,45 @@
+/*
+ * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH
+ * under one or more contributor license agreements. Licensed under a commercial license.
+ * You may not use this file except in compliance with the commercial license.
+ */
+import { ConsolePermissions, OrganizationRole, } from '@camunda/ccma-shared-types';
+import { describe, expect, it } from 'vitest';
+import { deriveConsoleAuthzFromAccessToken } from './c4-console-authz.js';
+function base64UrlEncode(input) {
+    return btoa(input).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+}
+function makeFakeJwt(payload) {
+    const header = { alg: 'none', typ: 'JWT' };
+    const encodedHeader = base64UrlEncode(JSON.stringify(header));
+    const encodedPayload = base64UrlEncode(JSON.stringify(payload));
+    return `${encodedHeader}.${encodedPayload}.`;
+}
+describe('deriveConsoleAuthzFromAccessToken', () => {
+    it('extracts permissions and org roles from the token', () => {
+        const token = makeFakeJwt({
+            permissions: [ConsolePermissions.CLUSTERS_DELETE_CLUSTER],
+            'https://camunda.com/orgs': [
+                { id: 'org-1', roles: [OrganizationRole.ADMIN] },
+                { id: 'org-2', roles: [OrganizationRole.VISITOR] },
+            ],
+        });
+        const result = deriveConsoleAuthzFromAccessToken({
+            accessToken: token,
+            orgId: 'org-1',
+        });
+        expect(result.tokenPermissions).toContain(ConsolePermissions.CLUSTERS_DELETE_CLUSTER);
+        expect(result.orgRoles).toEqual([OrganizationRole.ADMIN]);
+        expect(result.features.console.clusters.canDeleteAllClusters).toBe(true);
+        expect(result.visibilities.clusters?.canDelete).toBe(true);
+    });
+    it('is safe on invalid tokens', () => {
+        const result = deriveConsoleAuthzFromAccessToken({
+            accessToken: 'not-a-jwt',
+            orgId: 'org-1',
+        });
+        expect(result.tokenPermissions).toEqual([]);
+        expect(result.orgRoles).toEqual([]);
+        expect(result.visibilities.clusters?.canDelete).toBe(false);
+    });
+});

package/lib/esm/runtime/c4-console-data-context.d.ts

@@ -0,0 +1,38 @@
+import type React from 'react';
+import type { C4ConsoleDataState } from './c4-console-data-context.types';
+import { type ConsoleDataStoreSnapshotIn } from './c4-console-data-store';
+export interface C4ConsoleDataProviderProps {
+    children: React.ReactNode;
+    /**
+     * Optional cache seed used once at provider initialization.
+     * Intended for tests to avoid network calls.
+     */
+    initialState?: Partial<ConsoleDataStoreSnapshotIn>;
+}
+/**
+ * Provider component for shared console data.
+ * Must be nested inside C4ConsoleRuntimeProvider.
+ *
+ * @example
+ * <C4ConsoleRuntimeProvider config={runtime}>
+ *   <C4ConsoleDataProvider>
+ *     <C4DashboardApp orgId="123" />
+ *   </C4ConsoleDataProvider>
+ * </C4ConsoleRuntimeProvider>
+ */
+export declare const C4ConsoleDataProvider: ({ children, initialState, }: C4ConsoleDataProviderProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access shared console data state
+ *
+ * Must be used within C4ConsoleDataProvider.
+ *
+ * @example
+ * const data = useC4ConsoleData()
+ *
+ * useEffect(() => {
+ *   data.fetchClusters(orgId)
+ * }, [orgId])
+ *
+ * const clusters = data.getClusters(orgId) ?? []
+ */
+export declare const useC4ConsoleData: () => C4ConsoleDataState;

package/lib/esm/runtime/c4-console-data-context.js

@@ -0,0 +1,229 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+ * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH
+ * under one or more contributor license agreements. Licensed under a commercial license.
+ * You may not use this file except in compliance with the commercial license.
+ */
+import { SseEntity, SseType } from '@camunda/ccma-shared-types';
+import { onSnapshot } from 'mobx-state-tree';
+import { createContext, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState, } from 'react';
+import { addC4ConsoleNotification } from '../notifications/c4-console-notifications-handle.js';
+import { ConsoleDataStore, } from './c4-console-data-store.js';
+import { useC4ConsoleRuntime } from './c4-console-runtime-context.js';
+/**
+ * Shared data context for C4 console widgets
+ *
+ * Provides centralized data caching to avoid duplicate API requests.
+ * Internal implementation uses MobX State Tree for reactive state.
+ * External API is pure React Context hooks (framework-agnostic).
+ */
+const DataContext = createContext(undefined);
+/**
+ * Provider component for shared console data.
+ * Must be nested inside C4ConsoleRuntimeProvider.
+ *
+ * @example
+ * <C4ConsoleRuntimeProvider config={runtime}>
+ *   <C4ConsoleDataProvider>
+ *     <C4DashboardApp orgId="123" />
+ *   </C4ConsoleDataProvider>
+ * </C4ConsoleRuntimeProvider>
+ */
+export const C4ConsoleDataProvider = ({ children, initialState, }) => {
+    const runtime = useC4ConsoleRuntime();
+    const initialStateRef = useRef(initialState);
+    // Create store instance (stable across renders)
+    const store = useMemo(() => {
+        return ConsoleDataStore.create({
+            clusters: {},
+            members: {},
+            audits: {},
+            clusterCapacity: {},
+            ...initialStateRef.current,
+        });
+    }, []);
+    // Re-render provider consumers whenever the MST store changes.
+    const [storeVersion, setStoreVersion] = useState(0);
+    useEffect(() => {
+        return onSnapshot(store, () => {
+            setStoreVersion((prev) => prev + 1);
+        });
+    }, [store]);
+    // Inject runtime config into store before child effects run
+    useLayoutEffect(() => {
+        store.setRuntime(runtime);
+    }, [runtime, store]);
+    // Stable action wrappers (avoid recreating function identities on every snapshot)
+    const fetchClusters = useCallback((orgId, options) => store.fetchClusters(orgId, options), [store]);
+    const fetchMembers = useCallback((orgId, options) => store.fetchMembers(orgId, options), [store]);
+    const fetchAudits = useCallback((orgId, options) => store.fetchAudits(orgId, options), [store]);
+    const fetchClusterCapacity = useCallback((orgId, clusterIds, options) => store.fetchClusterCapacity(orgId, clusterIds, options), [store]);
+    const invalidateClusters = useCallback((orgId) => store.invalidateClusters(orgId), [store]);
+    const invalidateClusterCapacity = useCallback((orgId) => store.invalidateClusterCapacity(orgId), [store]);
+    const invalidateMembers = useCallback((orgId) => store.invalidateMembers(orgId), [store]);
+    const invalidateAudits = useCallback((orgId) => store.invalidateAudits(orgId), [store]);
+    const invalidateAll = useCallback((orgId) => store.invalidateAll(orgId), [store]);
+    const getClusters = useCallback((orgId) => store.getClusters(orgId), [store]);
+    const getMembers = useCallback((orgId) => store.getMembers(orgId), [store]);
+    const getAudits = useCallback((orgId) => store.getAudits(orgId), [store]);
+    const getClusterCapacity = useCallback((orgId, clusterId) => store.getClusterCapacity(orgId, clusterId), [store]);
+    const getSseEntityVersion = useCallback((orgId, entity, clusterId) => store.getSseEntityVersion(orgId, entity, clusterId), [store]);
+    const api = useMemo(() => ({
+        get clusters() {
+            const result = {};
+            store.clusters.forEach((value, key) => {
+                result[key] = {
+                    data: value.data,
+                    isLoading: value.isLoading,
+                    error: (value.error ?? undefined),
+                    lastFetched: value.lastFetched ?? undefined,
+                };
+            });
+            return result;
+        },
+        get members() {
+            const result = {};
+            store.members.forEach((value, key) => {
+                result[key] = {
+                    data: value.data,
+                    isLoading: value.isLoading,
+                    error: (value.error ?? undefined),
+                    lastFetched: value.lastFetched ?? undefined,
+                };
+            });
+            return result;
+        },
+        get audits() {
+            const result = {};
+            store.audits.forEach((value, key) => {
+                result[key] = {
+                    data: value.data,
+                    isLoading: value.isLoading,
+                    error: (value.error ?? undefined),
+                    lastFetched: value.lastFetched ?? undefined,
+                };
+            });
+            return result;
+        },
+        get clusterCapacity() {
+            const result = {};
+            store.clusterCapacity.forEach((value, key) => {
+                result[key] = value;
+            });
+            return result;
+        },
+        // Actions
+        fetchClusters,
+        fetchMembers,
+        fetchAudits,
+        fetchClusterCapacity,
+        // Invalidation
+        invalidateClusters,
+        invalidateClusterCapacity,
+        invalidateMembers,
+        invalidateAudits,
+        invalidateAll,
+        // Convenience getters
+        getClusters,
+        getMembers,
+        getAudits,
+        getClusterCapacity,
+        getSseEntityVersion,
+    }), [
+        store,
+        storeVersion,
+        fetchClusters,
+        fetchMembers,
+        fetchAudits,
+        fetchClusterCapacity,
+        invalidateClusters,
+        invalidateClusterCapacity,
+        invalidateMembers,
+        invalidateAudits,
+        invalidateAll,
+        getClusters,
+        getMembers,
+        getAudits,
+        getClusterCapacity,
+        getSseEntityVersion,
+    ]);
+    // Subscribe to console SSE updates (via window CustomEvent 'clusterchange')
+    useEffect(() => {
+        const handler = (event) => {
+            const detail = event.detail;
+            store.handleClusterChange(detail);
+            const parsed = detail;
+            const orgId = typeof parsed.org === 'string' ? parsed.org : undefined;
+            const entity = parsed.entity;
+            const sseType = parsed.type;
+            const clusterId = typeof parsed.clusterId === 'string' ? parsed.clusterId : undefined;
+            const payload = parsed.payload;
+            if (!orgId) {
+                return;
+            }
+            // Only emit notifications for the org currently visible in the URL.
+            if (!window.location.pathname.includes(`/org/${orgId}`)) {
+                return;
+            }
+            if (entity === SseEntity.CLUSTER &&
+                (sseType === SseType.CREATED || sseType === SseType.UPGRADED) &&
+                clusterId &&
+                typeof payload?.name === 'string') {
+                const clusterUrlPath = `/org/${orgId}/cluster/${clusterId}`;
+                const alreadyOnClusterPage = window.location.pathname.includes(clusterUrlPath);
+                if (!alreadyOnClusterPage) {
+                    addC4ConsoleNotification({
+                        title: 'Cluster ready for use',
+                        subtitle: `${payload.name} is healthy and ready to use`,
+                        action: {
+                            text: 'Manage Cluster',
+                            link: clusterUrlPath,
+                        },
+                        kind: 'success',
+                    });
+                }
+            }
+            if (entity === SseEntity.BACKUP &&
+                (sseType === SseType.CREATED || sseType === SseType.FAILED) &&
+                clusterId &&
+                typeof payload?.name === 'string') {
+                const clusterUrlPath = `/org/${orgId}/cluster/${clusterId}`;
+                addC4ConsoleNotification({
+                    title: `Backup ${String(sseType)}`,
+                    subtitle: `Backup ${payload.name} ${String(sseType)}`,
+                    action: {
+                        text: 'Manage Cluster',
+                        link: clusterUrlPath,
+                    },
+                    kind: sseType === SseType.FAILED ? 'error' : 'success',
+                });
+            }
+        };
+        window.addEventListener('clusterchange', handler);
+        return () => {
+            window.removeEventListener('clusterchange', handler);
+        };
+    }, [store]);
+    return _jsx(DataContext.Provider, { value: api, children: children });
+};
+/**
+ * Hook to access shared console data state
+ *
+ * Must be used within C4ConsoleDataProvider.
+ *
+ * @example
+ * const data = useC4ConsoleData()
+ *
+ * useEffect(() => {
+ *   data.fetchClusters(orgId)
+ * }, [orgId])
+ *
+ * const clusters = data.getClusters(orgId) ?? []
+ */
+export const useC4ConsoleData = () => {
+    const context = useContext(DataContext);
+    if (!context) {
+        throw new Error('useC4ConsoleData must be used within C4ConsoleDataProvider');
+    }
+    return context;
+};

package/lib/esm/runtime/c4-console-data-context.types.d.ts

@@ -0,0 +1,49 @@
+import type { SseEntity } from '@camunda/ccma-shared-types';
+/**
+ * Shared data cache state for C4 console widgets
+ *
+ * This provides a centralized cache to avoid duplicate API requests
+ * when multiple widgets need the same data (e.g., clusters, members).
+ */
+export interface CacheState<T> {
+    data: T | undefined;
+    isLoading: boolean;
+    error: Error | undefined;
+    lastFetched: Date | undefined;
+}
+export type OrgCache<T> = Record<string, CacheState<T>>;
+export interface C4ConsoleDataState {
+    clusters: OrgCache<any[]>;
+    members: OrgCache<any[]>;
+    audits: OrgCache<any[]>;
+    clusterCapacity: Record<string, Map<string, number>>;
+    fetchClusters: (orgId: string, options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    fetchMembers: (orgId: string, options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    fetchAudits: (orgId: string, options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    fetchClusterCapacity: (orgId: string, clusterIds: string[], options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    invalidateClusters: (orgId: string) => void;
+    invalidateClusterCapacity: (orgId: string) => void;
+    invalidateMembers: (orgId: string) => void;
+    invalidateAudits: (orgId: string) => void;
+    invalidateAll: (orgId: string) => void;
+    getClusters: (orgId: string) => any[] | undefined;
+    getMembers: (orgId: string) => any[] | undefined;
+    getAudits: (orgId: string) => any[] | undefined;
+    getClusterCapacity: (orgId: string, clusterId: string) => number | undefined;
+    /**
+     * Returns a monotonically increasing number that changes when C4 observes an
+     * SSE event for the given entity.
+     *
+     * Widgets can use this in a `useEffect` dependency array to re-run their
+     * existing reload logic without directly subscribing to window events.
+     */
+    getSseEntityVersion: (orgId: string, entity: SseEntity, clusterId?: string) => number;
+}

package/lib/esm/runtime/c4-console-data-context.types.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH
+ * under one or more contributor license agreements. Licensed under a commercial license.
+ * You may not use this file except in compliance with the commercial license.
+ */
+export {};