304 lines
18 KiB
TypeScript
304 lines
18 KiB
TypeScript
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<string>(['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 ? <time dateTime={value}>{new Date(value).toLocaleString('de-DE')}</time> : <>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 <details>
|
|
<summary>MCP mit curl verwenden</summary>
|
|
<p>Verwenden Sie den erstellten Token bei jeder Anfrage an <code>{endpoint}</code> im HTTP-Header <code>Authorization: Bearer <MCP-Token></code>.</p>
|
|
<p>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.</p>
|
|
<pre><code>{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"}'
|
|
)`}</code></pre>
|
|
</details>;
|
|
}
|
|
|
|
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 <TokenManagement key={context} auth={auth} tenantId={tenantId}/>;
|
|
}
|
|
|
|
function TokenManagement({ auth, tenantId }: { auth: Session; tenantId: string }) {
|
|
const path = tenantPath(tenantId, '/mcp-tokens');
|
|
const [listing, setListing] = useState<Listing | null>(null);
|
|
const [name, setName] = useState('');
|
|
const [selected, setSelected] = useState<Scope[]>([]);
|
|
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<string | null>(null);
|
|
const [history, setHistory] = useState(false);
|
|
const [editing, setEditing] = useState(false);
|
|
const mounted = useRef(false);
|
|
const mutation = useRef<AbortController | null>(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<HTMLFormElement>) {
|
|
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 <section aria-label="MCP-Tokens">
|
|
<h2>MCP-Tokens</h2>
|
|
<p>Erstellen Sie einen Zugang für Ihren MCP-Client. Jeder Skriptauftrag benötigt eine Genehmigung in der WebUI.</p>
|
|
<p><code>{endpoint}</code>{' '}
|
|
<button className="quiet" type="button" onClick={async () => {
|
|
try { await navigator.clipboard.writeText(endpoint); setNotice('MCP-Adresse wurde kopiert.'); }
|
|
catch { setNotice('Die MCP-Adresse kann oben markiert und kopiert werden.'); }
|
|
}}>MCP-Adresse kopieren</button></p>
|
|
{error && <p className="error" role="alert">{error}</p>}
|
|
{notice && <p role="status">{notice}</p>}
|
|
{secret && <article aria-label="Neu erstelltes MCP-Token">
|
|
<h3>Token für {secret.name}</h3>
|
|
<p>Kopieren Sie diesen Token jetzt. Nach dem Schließen dieser Anzeige ist der Geheimwert nicht erneut abrufbar.</p>
|
|
<label>Einmaliger Token<textarea readOnly rows={3} value={secret.token} autoComplete="off" spellCheck={false}/></label>
|
|
<button type="button" onClick={() => void copy()}>Token kopieren</button>
|
|
<button type="button" onClick={() => { setSecret(null); setNotice(''); }}>Tokenanzeige schließen</button>
|
|
</article>}
|
|
{!listing ? <p role="status">Tokenliste wird geladen …</p> : <>
|
|
{!editing && !secret && listing.allowed_scopes.length > 0 &&
|
|
<button type="button" className="primary" onClick={() => setEditing(true)}>Neues Token</button>}
|
|
{editing && !secret && <form onSubmit={create}>
|
|
<fieldset disabled={busy || secret !== null || listing.allowed_scopes.length === 0}>
|
|
<legend>Neues MCP-Token</legend>
|
|
<label>Name<input value={name} onChange={e => setName(e.target.value)} maxLength={240} required autoComplete="off" placeholder="Zum Beispiel mein MCP-Client"/></label>
|
|
{listing.available_customers && <fieldset><legend>Kundenzugriff</legend>
|
|
{listing.can_select_all && <label><input type="checkbox" checked={allCustomers} onChange={e => setAllCustomers(e.target.checked)}/>Alle aktuellen und zukünftigen Kunden</label>}
|
|
{!allCustomers && listing.available_customers.map(customer => <label key={customer.tenant_id}><input type="checkbox" checked={customerIds.includes(customer.tenant_id)}
|
|
onChange={e => setCustomerIds(previous => e.target.checked ? [...previous, customer.tenant_id] : previous.filter(id => id !== customer.tenant_id))}/>{customer.name}</label>)}
|
|
</fieldset>}
|
|
<fieldset><legend>Rechte</legend>
|
|
{listing.allowed_scopes.map(scope => <label key={scope}>
|
|
<input type="checkbox" checked={selected.includes(scope)} onChange={e => setSelected(current => e.target.checked ? [...current, scope] : current.filter(s => s !== scope))}/>
|
|
{scopeLabels[scope]} <code>{scope}</code>
|
|
</label>)}
|
|
</fieldset>
|
|
<label>Ablaufdatum und Uhrzeit<input type="datetime-local" required value={expires} onChange={e => setExpires(e.target.value)}/></label>
|
|
<small>Ortszeit dieses Browsers. Höchstens 365 Tage Gültigkeit.</small>
|
|
<button disabled={!selected.length || (!allCustomers && !customerIds.length)} type="submit">Token erstellen</button>
|
|
<button className="quiet" type="button" onClick={() => setEditing(false)}>Abbrechen</button>
|
|
</fieldset>
|
|
{listing.allowed_scopes.length === 0 && <p>Ihre Mitgliedschaft bietet keine Rechte für ein MCP-Token.</p>}
|
|
</form>}
|
|
<McpCurlHelp/>
|
|
<h3>Ausgestellte Tokens</h3>
|
|
<div className="fleet-tabs">
|
|
<button type="button" aria-pressed={!history} onClick={() => {setHistory(false); setRevokeId(null);}}>Aktiv</button>
|
|
<button type="button" aria-pressed={history} onClick={() => {setHistory(true); setRevokeId(null);}}>Verlauf</button>
|
|
</div>
|
|
<button type="button" disabled={busy} onClick={() => { setError(''); setReload(value => value + 1); }}>Tokenliste aktualisieren</button>
|
|
{!visibleTokens.length ? <p>{history ? 'Keine widerrufenen oder abgelaufenen Tokens.' : 'Keine aktiven Tokens.'}</p> : <div className="table"><table>
|
|
<thead><tr><th>Name und ID</th><th>Kundenzugriff</th><th>Rechte</th><th>Erstellt und zuletzt verwendet</th><th>Gültigkeit</th><th>Verwaltung</th></tr></thead>
|
|
<tbody>{visibleTokens.map(token => <tr key={token.token_id}>
|
|
<td>{token.name}<small><code>{token.token_id}</code></small><small>{token.principal}</small></td>
|
|
<td>{token.audience === 'all' ? 'Alle aktuellen und zukünftigen Kunden' : (token.tenant_ids ?? [tenantId]).map(id => listing.available_customers?.find(c => c.tenant_id === id)?.name ?? auth.tenants.find(c => c.tenant_id === id)?.name ?? id).join(', ')}</td>
|
|
<td>{token.scopes.map(scope => <small key={scope}>{scopeLabels[scope]} <code>{scope}</code></small>)}</td>
|
|
<td><DateLabel value={token.created_at}/><small>Zuletzt verwendet</small><DateLabel value={token.last_used_at}/></td>
|
|
<td>{token.revoked_at ? <>Widerrufen am <DateLabel value={token.revoked_at}/></> : <>{Date.parse(token.expires_at) <= Date.now() ? 'Abgelaufen am ' : 'Läuft ab am '}<DateLabel value={token.expires_at}/></>}</td>
|
|
<td>{!history && (revokeId === token.token_id ? <>
|
|
<p>Zugang für „{token.name}“ jetzt beenden?</p>
|
|
<button type="button" className="danger" disabled={busy} onClick={() => void revoke(token)}>Widerruf bestätigen</button>
|
|
<button type="button" disabled={busy} onClick={() => setRevokeId(null)}>Abbrechen</button>
|
|
</> : <button type="button" disabled={busy} onClick={() => setRevokeId(token.token_id)}>Widerrufen</button>)}</td>
|
|
</tr>)}</tbody>
|
|
</table></div>}
|
|
</>}
|
|
</section>;
|
|
}
|