Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

24.2 KB
Raw Blame
import {
  batch,
  createEffect,
  createMemo,
  createResource,
  createSignal,
  on,
  onCleanup,
  onMount,
} from 'solid-js';
import { fetchAgentCapabilitiesManifest } from '@/api/agentCapabilities';
import { unwrap } from 'solid-js/store';
import type { APITokenRecord } from '@/api/security';
import { SecurityAPI } from '@/api/security';
import { useWebSocket } from '@/contexts/appRuntime';
import { MONITORING_READ_SCOPE, API_SCOPE_LABELS } from '@/constants/apiScopes';
import {
  API_TOKEN_PRESET_QUERY_PARAM,
  PULSE_INTELLIGENCE_AGENT_TOKEN_PRESET,
} from '@/routing/resourceLinks';
import { useResources } from '@/hooks/useResources';
import { notificationStore } from '@/stores/notifications';
import { dismissTokenReveal, showTokenReveal, useTokenRevealState } from '@/stores/tokenReveal';
import type { Resource } from '@/types/resource';
import { formatRelativeTime } from '@/utils/format';
import {
  getAPITokenDockerPodmanUsageCountLabel,
  getAPITokenGenerateErrorMessage,
  getAPITokenRevealSettingsNote,
  getAPITokensLoadErrorMessage,
  getAPITokenRevokeErrorMessage,
  getAPITokenUpdateErrorMessage,
} from '@/utils/apiTokenPresentation';
import { logger } from '@/utils/logger';
import { eventBus } from '@/stores/events';
import { getOrgID } from '@/utils/apiClient';
import { getPulseBaseUrl } from '@/utils/url';
import {
  API_TOKEN_SCOPES_DOC_URL,
  API_TOKEN_PULSE_INTELLIGENCE_AGENT_PRESET_ID,
  API_TOKEN_WILDCARD_SCOPE,
  agentActionIdForResource,
  buildAgentTokenUsage,
  buildDockerTokenUsage,
  countWildcardTokens,
  dockerActionIdForResource,
  getAPITokenScopePresets,
  getAPITokenDialogName,
  getAPITokenHint,
  groupAPITokenScopes,
  hasAgentScopeResource,
  matchesScopePreset,
  revokedTokenIdForResource,
  sortAPITokensByCreatedAt,
  tokenIdForResource,
  tokenRevokedAtForResource,
} from './apiTokenManagerModel';

interface APITokenManagerProps {
  currentTokenHint?: string;
  currentUser?: string;
  onTokensChanged?: () => void;
  refreshing?: boolean;
  canManage?: boolean;
}

export const useAPITokenManagerState = (props: APITokenManagerProps) => {
  const { markDockerRuntimesTokenRevoked, markAgentsTokenRevoked } = useWebSocket();
  const { byType, resources } = useResources();

  const dockerRuntimeResources = createMemo(() => byType('docker-host'));
  const agentCapableResources = createMemo(() =>
    resources().filter((resource: Resource) => hasAgentScopeResource(resource)),
  );

  const dockerTokenUsage = createMemo(() => buildDockerTokenUsage(dockerRuntimeResources()));
  const agentTokenUsage = createMemo(() => buildAgentTokenUsage(agentCapableResources()));

  const [tokens, setTokens] = createSignal<APITokenRecord[]>([]);
  const [tokensLoaded, setTokensLoaded] = createSignal(false);
  const [loading, setLoading] = createSignal(true);
  const [loadError, setLoadError] = createSignal<string | null>(null);
  const [isGenerating, setIsGenerating] = createSignal(false);
  const [updatingTokenId, setUpdatingTokenId] = createSignal<string | null>(null);
  const [isRenaming, setIsRenaming] = createSignal(false);
  const [newTokenValue, setNewTokenValue] = createSignal<string | null>(null);
  const [newTokenRecord, setNewTokenRecord] = createSignal<APITokenRecord | null>(null);
  const [nameInput, setNameInput] = createSignal('');
  const [selectedScopes, setSelectedScopes] = createSignal<string[]>([]);
  const [agentCapabilitiesManifest] = createResource(fetchAgentCapabilitiesManifest);
  const tokenRevealState = useTokenRevealState();
  const managementAllowed = createMemo(() => props.canManage !== false);
  const authenticatedUser = createMemo(() => props.currentUser);
  const currentOrg = () => getOrgID() || 'default';
  const [selectedOrg, setSelectedOrg] = createSignal(currentOrg());
  const [selectedUser, setSelectedUser] = createSignal(authenticatedUser());
  const [contextVersion, setContextVersion] = createSignal(0);
  const [isMutating, setIsMutating] = createSignal(false);
  let disposed = false;
  let readController: AbortController | undefined;
  let mutationController: AbortController | undefined;
  let ownedReveal: ReturnType<typeof tokenRevealState> = null;
  let inventoryVersion = 0;
  const recordBindings = new WeakMap<APITokenRecord, number>();
  const rememberToken = (record: APITokenRecord) => {
    recordBindings.set(unwrap(record), inventoryVersion);
    return record;
  };
  const contextIsCurrent = () =>
    !disposed && selectedOrg() === currentOrg() && selectedUser() === authenticatedUser();
  const canManage = () => contextIsCurrent() && managementAllowed();
  const isCurrentRecord = (record: APITokenRecord) =>
    tokensLoaded() &&
    recordBindings.get(unwrap(record)) === inventoryVersion &&
    tokens().some((current) => current.id === record.id);

  const clearTokenValue = () => {
    // A different issuer may have replaced the global dialog. Never dismiss theirs.
    if (ownedReveal && tokenRevealState() === ownedReveal) dismissTokenReveal();
    ownedReveal = null;
    setNewTokenValue(null);
    setNewTokenRecord(null);
  };

  const invalidateRequests = () => {
    inventoryVersion += 1;
    setContextVersion((version) => version + 1);
    readController?.abort();
    readController = undefined;
    mutationController?.abort();
    mutationController = undefined;
    batch(() => {
      setIsMutating(false);
      setIsGenerating(false);
      setUpdatingTokenId(null);
      setIsRenaming(false);
      clearTokenValue();
    });
  };

  const beginMutation = () => {
    if (!canManage() || mutationController) return;
    const controller = new AbortController();
    const version = contextVersion();
    const org = selectedOrg();
    // A snapshot started before a write must not erase its accepted result or
    // mark the newly issued credential revoked. Resume only this interrupted read.
    const resumeRead = Boolean(readController);
    readController?.abort();
    readController = undefined;
    mutationController = controller;
    setIsMutating(true);
    const isCurrent = () =>
      mutationController === controller && version === contextVersion() && canManage();
    return {
      options: { signal: controller.signal, expectedOrgID: org },
      isCurrent,
      finish: () => {
        if (mutationController !== controller) return;
        mutationController = undefined;
        batch(() => {
          setIsMutating(false);
          setIsGenerating(false);
          setUpdatingTokenId(null);
          setIsRenaming(false);
        });
        if (resumeRead && contextIsCurrent()) void loadTokens();
      },
    };
  };

  const sortedTokens = createMemo(() => sortAPITokensByCreatedAt(tokens()));
  const totalTokens = createMemo(() => sortedTokens().length);
  const wildcardCount = createMemo(() => countWildcardTokens(sortedTokens()));
  const scopedTokenCount = createMemo(() => totalTokens() - wildcardCount());
  const hasWildcardTokens = createMemo(() => wildcardCount() > 0);
  const scopeGroups = createMemo(() => groupAPITokenScopes());
  const scopePresets = createMemo(() =>
    getAPITokenScopePresets(agentCapabilitiesManifest()?.requiredScopes ?? []),
  );
  const pulseIntelligenceAgentPreset = createMemo(() =>
    scopePresets().find((preset) => preset.id === API_TOKEN_PULSE_INTELLIGENCE_AGENT_PRESET_ID),
  );
  const hasScopeSelection = () => selectedScopes().length > 0;
  const isFullAccessSelected = () => selectedScopes().includes(API_TOKEN_WILDCARD_SCOPE);
  const canGenerateToken = () => canManage() && hasScopeSelection() && !isMutating();

  let createSectionRef: HTMLDivElement | undefined;
  const [createHighlight, setCreateHighlight] = createSignal(false);
  const [createSectionReady, setCreateSectionReady] = createSignal(false);
  const [requestedTokenPreset, setRequestedTokenPreset] = createSignal('');
  const [appliedRoutePreset, setAppliedRoutePreset] = createSignal('');
  const [focusedRoutePreset, setFocusedRoutePreset] = createSignal('');
  let highlightTimer: number | undefined;
  let routeFocusTimer: number | undefined;

  const readRequestedTokenPreset = () => {
    if (typeof window === 'undefined') return '';
    return (
      new URLSearchParams(window.location.search).get(API_TOKEN_PRESET_QUERY_PARAM)?.trim() ?? ''
    );
  };

  const setCreateSectionRef = (element: HTMLDivElement) => {
    createSectionRef = element;
    setCreateSectionReady(true);
  };

  const findScrollableAncestor = (element: HTMLElement): HTMLElement | null => {
    let current = element.parentElement;
    while (current) {
      const style = window.getComputedStyle(current);
      const canScroll =
        (style.overflowY === 'auto' || style.overflowY === 'scroll') &&
        current.scrollHeight > current.clientHeight;
      if (canScroll) {
        return current;
      }
      current = current.parentElement;
    }
    return null;
  };

  const focusCreateSection = () => {
    if (!canManage() || !createSectionRef) return;
    if (typeof createSectionRef.scrollIntoView === 'function') {
      createSectionRef.scrollIntoView({ behavior: 'smooth', block: 'start' });
    }
    const scrollParent = findScrollableAncestor(createSectionRef);
    if (scrollParent && typeof scrollParent.scrollTo === 'function') {
      const parentRect = scrollParent.getBoundingClientRect();
      const sectionRect = createSectionRef.getBoundingClientRect();
      scrollParent.scrollTo({
        top: Math.max(0, scrollParent.scrollTop + sectionRect.top - parentRect.top - 16),
        behavior: 'smooth',
      });
    }
    setCreateHighlight(true);
    window.clearTimeout(highlightTimer);
    highlightTimer = window.setTimeout(() => setCreateHighlight(false), 1600);
  };

  onCleanup(() => {
    if (highlightTimer) window.clearTimeout(highlightTimer);
    if (routeFocusTimer) window.clearTimeout(routeFocusTimer);
  });

  const loadTokens = async () => {
    if (!contextIsCurrent() || readController || mutationController) return;
    const controller = new AbortController();
    const version = contextVersion();
    readController = controller;
    const isCurrent = () =>
      readController === controller && version === contextVersion() && contextIsCurrent();
    setLoading(true);
    setTokensLoaded(false);
    setLoadError(null);
    try {
      const list = await SecurityAPI.listTokens({
        signal: controller.signal,
        expectedOrgID: selectedOrg(),
      });
      if (!isCurrent()) return;
      // Keyed table reconciliation retains a row's raw object across confirmed
      // edits. Bind accepted objects to this read, not the latest replacement's
      // identity, while excluding every object from an earlier inventory read.
      inventoryVersion += 1;
      list.forEach(rememberToken);
      setTokens(list);
      setTokensLoaded(true);
    } catch (err) {
      if (!isCurrent()) return;
      setLoadError(getAPITokensLoadErrorMessage());
      logger.error('Failed to load API tokens', err);
      notificationStore.error(getAPITokensLoadErrorMessage());
    } finally {
      if (isCurrent()) {
        readController = undefined;
        setLoading(false);
      }
    }
  };

  const resetContext = () => {
    if (disposed) return;
    const selectionChanged =
      selectedOrg() !== currentOrg() || selectedUser() !== authenticatedUser();
    invalidateRequests();
    batch(() => {
      setSelectedOrg(currentOrg());
      setSelectedUser(authenticatedUser());
      setTokens([]);
      setTokensLoaded(false);
      setLoadError(null);
      if (selectionChanged) {
        setNameInput('');
        setSelectedScopes([]);
      }
    });
    // Read-only accounts retain inventory recovery. Never replay an interrupted write.
    void loadTokens();
  };

  // Settings refreshes replace the status object. Equal authority/principal
  // values are not withdrawal: memo equality keeps a newly revealed token usable.
  createEffect(on([managementAllowed, authenticatedUser], resetContext, { defer: true }));
  const unsubscribeOrg = eventBus.on('org_switched', resetContext);
  onCleanup(() => {
    disposed = true;
    invalidateRequests();
    unsubscribeOrg();
    setTokens([]);
  });

  onMount(() => {
    setRequestedTokenPreset(readRequestedTokenPreset());
    const handleRoutePresetChange = () => {
      setRequestedTokenPreset(readRequestedTokenPreset());
    };
    window.addEventListener('hashchange', handleRoutePresetChange);
    window.addEventListener('popstate', handleRoutePresetChange);
    void loadTokens();
    onCleanup(() => {
      window.removeEventListener('hashchange', handleRoutePresetChange);
      window.removeEventListener('popstate', handleRoutePresetChange);
    });
  });

  createEffect(() => {
    const requestedPreset = requestedTokenPreset();
    if (
      requestedPreset !== PULSE_INTELLIGENCE_AGENT_TOKEN_PRESET ||
      appliedRoutePreset() === requestedPreset
    ) {
      return;
    }

    const preset = pulseIntelligenceAgentPreset();
    if (!preset || preset.scopes.length === 0) {
      return;
    }

    applyScopePreset(preset.scopes);
    if (!nameInput().trim()) {
      setNameInput(preset.label);
    }
    setAppliedRoutePreset(requestedPreset);
  });

  createEffect(() => {
    const requestedPreset = requestedTokenPreset();
    if (requestedPreset !== PULSE_INTELLIGENCE_AGENT_TOKEN_PRESET) {
      setFocusedRoutePreset('');
      return;
    }
    if (
      !createSectionReady() ||
      loading() ||
      appliedRoutePreset() !== requestedPreset ||
      focusedRoutePreset() === requestedPreset
    ) {
      return;
    }

    focusCreateSection();
    window.clearTimeout(routeFocusTimer);
    routeFocusTimer = window.setTimeout(() => {
      if (requestedTokenPreset() === requestedPreset) {
        focusCreateSection();
      }
    }, 0);
    setFocusedRoutePreset(requestedPreset);
  });

  createEffect(() => {
    if (!tokensLoaded() || !contextIsCurrent()) return;
    const activeTokenIds = new Set(tokens().map((token) => token.id));
    const pendingRuntimesByToken = new Map<string, string[]>();

    for (const resource of dockerRuntimeResources()) {
      const tokenId = tokenIdForResource(resource);
      if (!tokenId || activeTokenIds.has(tokenId)) continue;
      if (revokedTokenIdForResource(resource) === tokenId) continue;

      if (!pendingRuntimesByToken.has(tokenId)) {
        pendingRuntimesByToken.set(tokenId, []);
      }
      const runtimeIds = pendingRuntimesByToken.get(tokenId)!;
      const runtimeId = dockerActionIdForResource(resource);
      if (!runtimeIds.includes(runtimeId)) runtimeIds.push(runtimeId);
    }

    pendingRuntimesByToken.forEach((runtimeIds, tokenId) => {
      if (runtimeIds.length > 0) markDockerRuntimesTokenRevoked(tokenId, runtimeIds);
    });

    const pendingAgentsByToken = new Map<string, string[]>();
    for (const resource of agentCapableResources()) {
      const tokenId = tokenIdForResource(resource);
      if (!tokenId || activeTokenIds.has(tokenId)) continue;
      if (revokedTokenIdForResource(resource) === tokenId && tokenRevokedAtForResource(resource)) {
        continue;
      }

      if (!pendingAgentsByToken.has(tokenId)) {
        pendingAgentsByToken.set(tokenId, []);
      }
      const agentIds = pendingAgentsByToken.get(tokenId)!;
      const agentId = agentActionIdForResource(resource);
      if (!agentIds.includes(agentId)) agentIds.push(agentId);
    }

    pendingAgentsByToken.forEach((agentIds, tokenId) => {
      if (agentIds.length > 0) markAgentsTokenRevoked(tokenId, agentIds);
    });
  });

  const applyScopePreset = (scopes: string[]) => {
    setSelectedScopes(Array.from(new Set(scopes)).filter(Boolean));
  };

  const applyFullAccessPreset = () => applyScopePreset([API_TOKEN_WILDCARD_SCOPE]);

  const clearScopes = () => setSelectedScopes([]);

  const toggleScope = (scope: string) => {
    setSelectedScopes((previous) => {
      if (previous.includes(scope)) {
        return previous.filter((value) => value !== scope);
      }
      return [...previous, scope];
    });
  };

  const handleGenerate = async () => {
    if (!canManage()) return;
    if (!hasScopeSelection()) {
      notificationStore.error('Choose a scope preset or custom scope before generating a token.');
      return;
    }
    const mutation = beginMutation();
    if (!mutation) return;
    setIsGenerating(true);
    try {
      const trimmedName = nameInput().trim() || undefined;
      const scopeSelection = [...selectedScopes()].sort();
      const scopePayload = scopeSelection.length > 0 ? scopeSelection : undefined;
      const { token, record } = await SecurityAPI.createToken(
        trimmedName,
        scopePayload,
        mutation.options,
      );
      if (!mutation.isCurrent()) return;

      rememberToken(record);
      setTokens((previous) => [record, ...previous]);
      setNewTokenRecord(record);
      setNewTokenValue(token);
      setNameInput('');

      showTokenReveal({
        token,
        record,
        source: 'security',
        note: getAPITokenRevealSettingsNote(),
      });
      ownedReveal = tokenRevealState();
      notificationStore.success(
        'New API token generated. Copy it below while it is still visible.',
      );
      props.onTokensChanged?.();
    } catch (err) {
      if (!mutation.isCurrent()) return;
      logger.error('Failed to generate API token', err);
      notificationStore.error(getAPITokenGenerateErrorMessage(err));
    } finally {
      mutation.finish();
    }
  };

  const handleDelete = async (record: APITokenRecord) => {
    if (!isCurrentRecord(record)) return;
    const mutation = beginMutation();
    if (!mutation) return;
    const dockerUsage = dockerTokenUsage().get(record.id);
    const agentUsage = agentTokenUsage().get(record.id);
    const displayName = getAPITokenDialogName(record);

    const affectedRuntimeIds = dockerUsage ? dockerUsage.items.map((item) => item.id) : [];
    const affectedAgentIds = agentUsage ? agentUsage.items.map((item) => item.id) : [];
    let revokeMessage: string | undefined;
    const messageChunks: string[] = [];

    if (dockerUsage) {
      const preview = dockerUsage.items
        .slice(0, 5)
        .map((item) => item.label)
        .join(', ');
      const extraCount = dockerUsage.items.length - 5;
      const summary = extraCount > 0 ? `${preview}, +${extraCount} more` : preview;
      const label = getAPITokenDockerPodmanUsageCountLabel(dockerUsage.count);
      messageChunks.push(`${label}: ${summary}`);
    }

    if (agentUsage) {
      const preview = agentUsage.items
        .slice(0, 5)
        .map((item) => item.label)
        .join(', ');
      const extraCount = agentUsage.items.length - 5;
      const summary = extraCount > 0 ? `${preview}, +${extraCount} more` : preview;
      const label = agentUsage.count === 1 ? 'agent' : `${agentUsage.count} agents`;
      messageChunks.push(`${label}: ${summary}`);
    }

    if (messageChunks.length > 0) {
      revokeMessage = `Token "${displayName}" was previously used by ${messageChunks.join(' • ')}. Update those agents with a new token.`;
    }

    try {
      await SecurityAPI.deleteToken(record.id, mutation.options);
      if (!mutation.isCurrent()) return;
      setTokens((previous) => previous.filter((token) => token.id !== record.id));
      notificationStore.success(
        revokeMessage ? `Token revoked: ${revokeMessage}` : 'Token revoked',
      );
      props.onTokensChanged?.();

      if (affectedRuntimeIds.length > 0) {
        markDockerRuntimesTokenRevoked(record.id, affectedRuntimeIds);
      }
      if (affectedAgentIds.length > 0) {
        markAgentsTokenRevoked(record.id, affectedAgentIds);
      }

      const current = newTokenRecord();
      if (current && current.id === record.id) {
        clearTokenValue();
      }
    } catch (err) {
      if (!mutation.isCurrent()) return;
      logger.error('Failed to revoke API token', err);
      notificationStore.error(getAPITokenRevokeErrorMessage());
    } finally {
      mutation.finish();
    }
  };

  const handleUpdateScopes = async (record: APITokenRecord, scopes: string[]) => {
    if (scopes.length === 0 || !isCurrentRecord(record)) return false;
    const mutation = beginMutation();
    if (!mutation) return false;

    setUpdatingTokenId(record.id);
    try {
      const updated = await SecurityAPI.updateTokenScopes(
        record.id,
        [...scopes].sort(),
        mutation.options,
      );
      if (!mutation.isCurrent()) return false;
      rememberToken(updated);
      setTokens((previous) => previous.map((token) => (token.id === updated.id ? updated : token)));
      if (newTokenRecord()?.id === updated.id) {
        setNewTokenRecord(updated);
      }
      notificationStore.success(`Scopes updated for ${getAPITokenDialogName(updated)}.`);
      props.onTokensChanged?.();
      return true;
    } catch (err) {
      if (!mutation.isCurrent()) return false;
      logger.error('Failed to update API token scopes', err);
      notificationStore.error(getAPITokenUpdateErrorMessage(err));
      return false;
    } finally {
      mutation.finish();
    }
  };

  const handleRename = async (record: APITokenRecord, name: string): Promise<boolean> => {
    if (!canManage() || !isCurrentRecord(record) || isMutating()) return false;
    const trimmedName = name.trim();
    if (!trimmedName) {
      notificationStore.error('Enter a token name.');
      return false;
    }

    const mutation = beginMutation();
    if (!mutation) return false;
    setIsRenaming(true);
    try {
      const updated = await SecurityAPI.renameToken(record.id, trimmedName, mutation.options);
      if (!mutation.isCurrent()) return false;
      rememberToken(updated);
      setTokens((previous) => previous.map((token) => (token.id === updated.id ? updated : token)));
      setNewTokenRecord((current) => (current?.id === updated.id ? updated : current));
      notificationStore.success('Token renamed');
      props.onTokensChanged?.();
      return true;
    } catch (err) {
      if (!mutation.isCurrent()) return false;
      logger.error('Failed to rename API token', err);
      notificationStore.error('Unable to rename the API token.');
      return false;
    } finally {
      mutation.finish();
    }
  };

  const isRevealActiveForCurrentToken = () => {
    const active = tokenRevealState();
    return newTokenValue() !== null && Boolean(active && active.token === newTokenValue());
  };

  const reopenTokenDialog = () => {
    const token = newTokenValue();
    const record = newTokenRecord();
    if (!canManage() || !token || !record) return;
    showTokenReveal({
      token,
      record,
      source: 'security',
      note: 'Copy this token now. Close the dialog once you have stored it safely.',
    });
    ownedReveal = tokenRevealState();
  };

  const dismissNewToken = () => {
    clearTokenValue();
  };

  const newMonitoringKioskLink = createMemo(() => {
    if (
      !canManage() ||
      !newTokenValue() ||
      newTokenRecord()?.scopes?.length !== 1 ||
      newTokenRecord()?.scopes?.[0] !== MONITORING_READ_SCOPE
    ) {
      return null;
    }
    return `${getPulseBaseUrl()}/?token=${newTokenValue()}&kiosk=1`;
  });

  const copyNewMonitoringKioskLink = async () => {
    const link = newMonitoringKioskLink();
    if (!canManage() || !link) return;
    const version = contextVersion();
    await navigator.clipboard.writeText(link);
    if (version !== contextVersion() || !canManage()) return;
    notificationStore.success('Link copied to clipboard');
  };

  return {
    API_SCOPE_LABELS,
    API_TOKEN_SCOPES_DOC_URL,
    agentTokenUsage,
    applyFullAccessPreset,
    applyScopePreset,
    canManage,
    contextVersion,
    isMutating,
    clearScopes,
    copyNewMonitoringKioskLink,
    createHighlight,
    dismissNewToken,
    dockerTokenUsage,
    focusCreateSection,
    formatRelativeTime,
    handleDelete,
    handleGenerate,
    handleUpdateScopes,
    handleRename,
    hasWildcardTokens,
    hasScopeSelection,
    isFullAccessSelected,
    isGenerating,
    updatingTokenId,
    isRenaming,
    isRevealActiveForCurrentToken,
    loading,
    loadError,
    loadTokens,
    tokensLoaded,
    nameInput,
    newMonitoringKioskLink,
    newTokenRecord,
    newTokenValue,
    reopenTokenDialog,
    scopedTokenCount,
    scopeGroups,
    scopePresets,
    selectedScopes,
    setCreateSectionRef,
    setNameInput,
    sortedTokens,
    tokenHint: getAPITokenHint,
    toggleScope,
    totalTokens,
    wildcardCount,
    presetMatchesSelection: (presetScopes: string[]) =>
      matchesScopePreset(selectedScopes(), presetScopes),
    canGenerateToken,
  };
};