import { useEffect, useRef, useState, type FormEvent } from 'react'; import { ApiError, record, request, tenant, tenantPath, type Tenant, type Session } from './api'; const scopeLabels = { 'inventory:read': 'Inventar lesen', 'logs:read': 'Gespeicherte Protokolle lesen', 'logs:read_sensitive': 'Sensible Protokolle lesen', 'operations:read': 'Aufträge und Ergebnisse lesen', 'operations:plan': 'Aufträge planen', 'operations:submit': 'Aufträge zur Genehmigung einreichen', 'jobs:cancel': 'Abbruch von Aufträgen anfordern', 'scripts:execute': 'Skriptaufträge anfordern', 'system:execute': 'SYSTEM-Aufträge anfordern', 'root:execute': 'root-Aufträge anfordern', 'updates:apply': 'Updateaufträge anfordern', 'catalog:write': 'Katalogeinträge schreiben', } as const; type Scope = keyof typeof scopeLabels; const readScopes = new Set(['inventory:read', 'logs:read', 'operations:read']); const day = 24 * 60 * 60 * 1000; export interface McpToken { token_id: string; name: string; principal: string; scopes: Scope[]; created_at: string; expires_at: string; last_used_at: string | null; revoked_at: string | null; audience?: 'selected' | 'all'; tenant_ids?: string[]; } interface Listing { tokens: McpToken[]; allowed_scopes: Scope[]; default_scopes: Scope[]; available_customers?: Tenant[]; can_select_all: boolean } function requireContract(condition: unknown): asserts condition { if (!condition) throw new Error('Ungültige Antwort der Tokenverwaltung'); } function scopes(value: unknown): Scope[] { requireContract(Array.isArray(value) && value.every(s => typeof s === 'string' && Object.hasOwn(scopeLabels, s)) && new Set(value).size === value.length); return [...value] as Scope[]; } function timestamp(value: unknown): string { requireContract(typeof value === 'string' && Number.isFinite(Date.parse(value))); return value; } export function mcpToken(value: unknown): McpToken { const r = record(value); requireContract(typeof r.token_id === 'string' && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(r.token_id) && typeof r.name === 'string' && r.name.length > 0 && typeof r.principal === 'string' && r.principal.length > 0); const audience = r.audience; if (audience !== undefined) { requireContract(audience === 'selected' || audience === 'all'); requireContract(Array.isArray(r.tenant_ids) && r.tenant_ids.every(id => typeof id === 'string')); requireContract(audience === 'all' ? r.tenant_ids.length === 0 : r.tenant_ids.length > 0); } return { ...(audience === undefined ? {} : { audience, tenant_ids: r.tenant_ids as string[] }), token_id: r.token_id, name: r.name, principal: r.principal, scopes: scopes(r.scopes), created_at: timestamp(r.created_at), expires_at: timestamp(r.expires_at), last_used_at: r.last_used_at === null ? null : timestamp(r.last_used_at), revoked_at: r.revoked_at === null ? null : timestamp(r.revoked_at) }; } export function mcpTokenListing(value: unknown): Listing { const r = record(value); requireContract(Array.isArray(r.tokens)); const allowed = scopes(r.allowed_scopes), defaults = scopes(r.default_scopes); requireContract(defaults.every(s => readScopes.has(s) && allowed.includes(s))); const tokens = r.tokens.map(mcpToken); requireContract(new Set(tokens.map(t => t.token_id)).size === tokens.length); if (r.available_customers !== undefined) requireContract(Array.isArray(r.available_customers)); return { tokens, allowed_scopes: allowed, default_scopes: defaults, available_customers: r.available_customers?.map(tenant), can_select_all: r.can_select_all === true }; } export function canManageMcpTokens(auth: Session, tenantId: string): boolean { return auth.principal.simulated === false && !!auth.csrf_token && auth.permissions?.includes('tokens:manage') === true && auth.tenants.some(tenant => tenant.tenant_id === tenantId); } export function mcpTokenDraft(name: string, selected: string[], allowed: string[], expires: string, now = Date.now()) { const cleanName = name.trim(), selectedScopes = scopes(selected), expiresAt = new Date(expires).getTime(); if (!cleanName || Array.from(cleanName).length > 120 || /\p{Cc}/u.test(cleanName)) throw new Error('Ein Name mit höchstens 120 Zeichen ist erforderlich.'); if (!selectedScopes.length || !selectedScopes.every(s => allowed.includes(s))) throw new Error('Mindestens ein verfügbares Recht auswählen.'); if (!Number.isFinite(expiresAt) || expiresAt <= now || expiresAt > now + 365 * day) throw new Error('Das Ablaufdatum muss in den nächsten 365 Tagen liegen.'); return { name: cleanName, scopes: selectedScopes, expires_at: new Date(expiresAt).toISOString() }; } function defaultExpiry(): string { const value = new Date(Date.now() + 90 * day); return new Date(value.getTime() - value.getTimezoneOffset() * 60000).toISOString().slice(0, 16); } function DateLabel({ value }: { value: string | null }) { return value ? : <>Bisher ungenutzt; } function requestFailure(error: unknown, fallback: string): string { if (error instanceof ApiError && [401, 403].includes(error.status)) return 'Die Sitzung oder Berechtigung ist abgelaufen. Bitte erneut anmelden.'; return fallback; } function McpCurlHelp() { const endpoint = new URL('/mcp', window.location.origin).href; return
MCP mit curl verwenden

Verwenden Sie den erstellten Token bei jeder Anfrage an {endpoint} im HTTP-Header Authorization: Bearer <MCP-Token>.

Führen Sie das Beispiel in Bash aus und fügen Sie den Token bei der verdeckten Eingabe ein. Das Beispiel startet eine Sitzung und listet die MCP-Werkzeuge auf.

{String.raw`(
  set -o pipefail
  read -rsp 'MCP-Token: ' mcp_token || exit 1
  printf '\n'

  mcp() {
    curl --fail --silent --show-error '${endpoint}' \
      --header @- \
      --header 'Content-Type: application/json' \
      --header 'Accept: application/json, text/event-stream' \
      --header 'MCP-Protocol-Version: 2025-11-25' \
      "$@" <<< "Authorization: Bearer $mcp_token"
  }

  session_id=$(mcp --dump-header - --output /dev/null --data '{
    "jsonrpc":"2.0","id":1,"method":"initialize","params":{
      "protocolVersion":"2025-11-25","capabilities":{},
      "clientInfo":{"name":"curl","version":"1.0"}
    }
  }' | awk 'tolower($1) == "mcp-session-id:" { sub(/\r$/, "", $2); print $2 }') || exit 1
  if [ -z "$session_id" ]; then
    printf '%s\n' 'Der Server hat keine MCP-Sitzungs-ID geliefert.' >&2
    exit 1
  fi

  mcp --header "Mcp-Session-Id: $session_id" \
    --data '{"jsonrpc":"2.0","method":"notifications/initialized"}' || exit 1
  mcp --header "Mcp-Session-Id: $session_id" \
    --data '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'
)`}
; } export function McpTokenManagement({ auth, tenantId }: { auth: Session; tenantId: string }) { if (!canManageMcpTokens(auth, tenantId)) return null; // Reset even an in-flight creation when the actual session, tenant or rights change. const context = JSON.stringify([tenantId, auth.principal.id, auth.csrf_token, auth.permissions]); return ; } function TokenManagement({ auth, tenantId }: { auth: Session; tenantId: string }) { const path = tenantPath(tenantId, '/mcp-tokens'); const [listing, setListing] = useState(null); const [name, setName] = useState(''); const [selected, setSelected] = useState([]); const [allCustomers, setAllCustomers] = useState(false); const [customerIds, setCustomerIds] = useState([tenantId]); const [expires, setExpires] = useState(defaultExpiry); const [secret, setSecret] = useState<{ token: string; tokenId: string; name: string } | null>(null); const [busy, setBusy] = useState(false); const [error, setError] = useState(''); const [notice, setNotice] = useState(''); const [reload, setReload] = useState(0); const [revokeId, setRevokeId] = useState(null); const [history, setHistory] = useState(false); const [editing, setEditing] = useState(false); const mounted = useRef(false); const mutation = useRef(null); useEffect(() => { mounted.current = true; return () => { mounted.current = false; mutation.current?.abort(); }; }, []); useEffect(() => { const controller = new AbortController(); request(path, { signal: controller.signal }).then(value => { if (controller.signal.aborted) return; const next = mcpTokenListing(value); setListing(next); setSelected(current => reload === 0 ? next.default_scopes : current.filter(s => next.allowed_scopes.includes(s))); }).catch(err => { if (!controller.signal.aborted) setError(requestFailure(err, 'Die Tokenliste konnte nicht geladen werden.')); }); return () => controller.abort(); }, [path, reload]); async function create(event: FormEvent) { event.preventDefault(); if (busy || secret || !listing) return; let body; try { body = mcpTokenDraft(name, selected, listing.allowed_scopes, expires); if (listing.available_customers) { if (allCustomers && !listing.can_select_all) throw new Error('Keine Berechtigung für alle Kunden.'); if (!allCustomers && (!customerIds.length || customerIds.some(id => !listing.available_customers!.some(c => c.tenant_id === id)))) throw new Error('Bitte mindestens einen verfügbaren Kunden auswählen.'); body = { ...body, audience: allCustomers ? 'all' : 'selected', tenant_ids: allCustomers ? [] : customerIds }; } } catch (err) { setError(err instanceof Error ? err.message : 'Tokenangaben prüfen.'); return; } setBusy(true); setError(''); setNotice(''); const controller = new AbortController(); mutation.current = controller; try { const reply = record(await request(path, { body, csrf: auth.csrf_token, signal: controller.signal })); if (!mounted.current) return; const metadata = mcpToken(reply); requireContract(typeof reply.token === 'string' && reply.token.length >= 32 && reply.token.length <= 512); setSecret({ token: reply.token, tokenId: metadata.token_id, name: metadata.name }); setEditing(false); setHistory(false); setListing(current => current && { ...current, tokens: [metadata, ...current.tokens] }); setName(''); setAllCustomers(false); setCustomerIds([tenantId]); setSelected(listing.default_scopes); setExpires(defaultExpiry()); } catch (err) { if (mounted.current) { setError(requestFailure(err, 'Die Erstellung konnte nicht bestätigt werden. Prüfen Sie vor einem neuen Versuch die aktualisierte Tokenliste.')); setReload(value => value + 1); } } finally { if (mounted.current) setBusy(false); } } async function revoke(token: McpToken) { if (busy) return; setBusy(true); setError(''); setNotice(''); const controller = new AbortController(); mutation.current = controller; try { const metadata = mcpToken(await request(`${path}/${encodeURIComponent(token.token_id)}/revoke`, { body: {}, csrf: auth.csrf_token, signal: controller.signal })); if (!mounted.current) return; requireContract(metadata.token_id === token.token_id && metadata.revoked_at !== null); setListing(current => current && { ...current, tokens: current.tokens.map(row => row.token_id === metadata.token_id ? metadata : row) }); if (secret?.tokenId === token.token_id) setSecret(null); setRevokeId(null); setNotice(`Token „${metadata.name}“ widerrufen.`); } catch (err) { if (mounted.current) { setError(requestFailure(err, 'Der Widerruf konnte nicht bestätigt werden. Der aktuelle Tokenstatus wird erneut geladen.')); setReload(value => value + 1); } } finally { if (mounted.current) setBusy(false); } } async function copy() { if (!secret) return; try { await navigator.clipboard.writeText(secret.token); if (mounted.current) setNotice('Token kopiert.'); } catch { if (mounted.current) setError('Kopieren ist im Browser nicht verfügbar. Sie können den angezeigten Token markieren und kopieren.'); } } const endpoint = typeof window === 'undefined' ? '/mcp' : window.location.origin + '/mcp'; const now = Date.now(); const visibleTokens = listing?.tokens.filter(token => (token.revoked_at !== null || Date.parse(token.expires_at) <= now) === history) ?? []; return

MCP-Tokens

Erstellen Sie einen Zugang für Ihren MCP-Client. Jeder Skriptauftrag benötigt eine Genehmigung in der WebUI.

{endpoint}{' '}

{error &&

{error}

} {notice &&

{notice}

} {secret &&

Token für {secret.name}

Kopieren Sie diesen Token jetzt. Nach dem Schließen dieser Anzeige ist der Geheimwert nicht erneut abrufbar.