Add local password-TOTP sessions and scoped revocable MCP tokens

This commit is contained in:
2026-11-17 20:05:28 +01:00
parent 7fe20df34f
commit 9fa0fb81ff
17 changed files with 1804 additions and 27 deletions
+3 -2
View File
@@ -13,14 +13,15 @@ export function stringField(value: RecordValue, key: string): string { return ty
export interface Tenant { tenant_id: string; name: string }
export interface Session { principal: { id: string; display_name: string; simulated: boolean }; tenants: Tenant[]; csrf_token: string; permissions?: string[]; roles?: string[] }
export interface Page { items: RecordValue[]; next_cursor: string | null; completeness: string; truncated: boolean; as_of: string }
export interface AuthConfig { oidc_configured: boolean; oidc_login_url: '/auth/oidc/login' | null; dev_login_enabled: boolean }
export interface AuthConfig { oidc_configured: boolean; oidc_login_url: '/auth/oidc/login' | null; dev_login_enabled: boolean; local_login_enabled: boolean }
export function authConfig(value: unknown): AuthConfig {
const r = record(value, 'Auth-Konfiguration');
if (typeof r.oidc_configured !== 'boolean' || typeof r.dev_login_enabled !== 'boolean') throw new Error('CONTRACT_ERROR: Anmeldemodi nicht ausdrücklich konfiguriert');
// Only the canonical same-origin server entrypoint is allowed. No issuer,
// return URL, query, fragment, credentials or externally supplied redirect.
if (r.oidc_configured ? r.oidc_login_url !== '/auth/oidc/login' : r.oidc_login_url !== null) throw new Error('CONTRACT_ERROR: OIDC-Anmeldepfad ungültig');
return { oidc_configured: r.oidc_configured, dev_login_enabled: r.dev_login_enabled, oidc_login_url: r.oidc_configured ? '/auth/oidc/login' : null };
if (r.local_login_enabled !== undefined && typeof r.local_login_enabled !== 'boolean') throw new Error('CONTRACT_ERROR: Lokale Anmeldung ungültig');
return { local_login_enabled: r.local_login_enabled === true, oidc_configured: r.oidc_configured, dev_login_enabled: r.dev_login_enabled, oidc_login_url: r.oidc_configured ? '/auth/oidc/login' : null };
}
export function tenant(value: unknown): Tenant { const r = record(value); return { tenant_id: text(r.tenant_id ?? r.id, 'tenant_id'), name: text(r.name, 'tenant.name') }; }
export function session(value: unknown): Session {
+11
View File
@@ -34,3 +34,14 @@ describe('server-announced auth configuration', () => {
expect(() => session({ principal: 'simulated-testprincipal-a', tenant_id: 't', csrf_token: 'csrf', roles: ['dev_test_member'] })).toThrow();
});
});
it('renders the local password and TOTP login only when explicitly enabled', () => {
const config = authConfig({ oidc_configured: false, oidc_login_url: null, dev_login_enabled: false, local_login_enabled: true });
const html = renderToStaticMarkup(<Login config={config} configError={null} onLogin={onLogin}/>);
expect(html).toContain('type="password"');
expect(html).toContain('Authenticator-Code');
expect(html).toContain('autoComplete="one-time-code"');
expect(html).not.toContain('SIMULIERTER');
expect(html).not.toContain('OIDC');
expect(() => authConfig({ oidc_configured:false, oidc_login_url:null, dev_login_enabled:false, local_login_enabled:'true' })).toThrow();
});
+27 -12
View File
@@ -1,19 +1,34 @@
import { useState } from 'react';
import { AuthConfig, request, session, Session } from './api';
export function Login({ config, configError, onLogin }: { config: AuthConfig | null; configError: string | null; onLogin: (s: Session) => void }) {
function CredentialsForm({ local, onLogin }: { local: boolean; onLogin: (s: Session) => void }) {
const [error, setError] = useState<string | null>(null), [busy, setBusy] = useState(false);
return <main className="login"><h1>RMM · Linux Verwaltung</h1>
{configError ? <div role="alert" className="error">Anmeldekonfiguration nicht verfügbar: {configError}. Keine unsichere Standardanmeldung. Bitte nach Behebung neu laden.</div> : !config ? <p>Anmeldemodi werden über die geschützte gleiche Origin geprüft …</p> : <>
{config.oidc_configured && config.oidc_login_url ? <section><h2>Single Sign-on</h2><p>Anmeldung über den serverseitig konfigurierten Identitätsanbieter. Zugangscodes und Tokens verarbeitet ausschließlich der Backend-Callback.</p><a href={config.oidc_login_url} rel="noreferrer">Mit SSO anmelden</a></section> : <p>OIDC: not_configured · kein Identitätsanbieter angekündigt.</p>}
{config.dev_login_enabled && <><p className="warning">DEV/TEST · SIMULIERTER TESTPRINCIPAL · ausschließlich Entwicklungsanmeldung, kein Produktionslogin und kein menschlicher Produktions-Freigabenachweis.</p><form onSubmit={async e => { e.preventDefault(); const form = e.currentTarget; const data = new FormData(form); setBusy(true); setError(null); try {
await request('/auth/dev/login', { body: { username: data.get('username'), password: data.get('password') } });
form.reset(); onLogin(session(await request('/auth/session')));
} catch (e) { setError(e instanceof Error ? e.message : 'Anmeldung fehlgeschlagen'); } finally { form.reset(); setBusy(false); } }}>
<label>Benutzername<input name="username" autoComplete="username" required maxLength={128}/></label>
<label>Passwort<input name="password" type="password" autoComplete="current-password" required maxLength={256}/></label>
<button disabled={busy}>Anmelden</button>{error && <div role="alert" className="error">{error}</div>}</form></>}
{!config.oidc_configured && !config.dev_login_enabled && <p className="warning">Anmeldung: not_configured · kein freigegebener Anmeldemodus verfügbar. Administrator kontaktieren.</p>}
return <form aria-label={local ? 'Passwort und Authenticator-Code' : 'Entwicklungsanmeldung'} onSubmit={async event => {
event.preventDefault();
const form = event.currentTarget, data = new FormData(form);
setBusy(true); setError(null);
try {
await request(local ? '/auth/local/login' : '/auth/dev/login', {
body: { username: data.get('username'), password: data.get('password'), ...(local ? { totp_code: data.get('totp') } : {}) }
});
form.reset(); onLogin(session(await request('/auth/session')));
} catch (error) { setError(error instanceof Error ? error.message : 'Anmeldung fehlgeschlagen'); }
finally { form.reset(); setBusy(false); }
}}>
<label>Benutzername<input name="username" autoComplete="username" required maxLength={128}/></label>
<label>Passwort<input name="password" type="password" autoComplete="current-password" required maxLength={256}/></label>
{local && <label>Authenticator-Code<input name="totp" type="text" inputMode="numeric" autoComplete="one-time-code" pattern="[0-9]{6}" minLength={6} maxLength={6} required/></label>}
<button disabled={busy}>Anmelden</button>{error && <div role="alert" className="error">{error}</div>}
</form>;
}
export function Login({ config, configError, onLogin }: { config: AuthConfig | null; configError: string | null; onLogin: (s: Session) => void }) {
return <main className="login"><h1>Rust Discovery</h1>
{configError ? <div role="alert" className="error">Anmeldekonfiguration nicht verfügbar: {configError}. Bitte nach Behebung neu laden.</div> : !config ? <p>Anmeldemodi werden geladen …</p> : <>
{config.local_login_enabled && <><h2>Anmelden</h2><CredentialsForm local onLogin={onLogin}/></>}
{config.oidc_configured && config.oidc_login_url ? <section><h2>Single Sign-on</h2><p>Anmeldung über den serverseitig konfigurierten Identitätsanbieter.</p><a href={config.oidc_login_url} rel="noreferrer">Mit SSO anmelden</a></section> : !config.local_login_enabled && <p>OIDC: not_configured · kein Identitätsanbieter angekündigt.</p>}
{config.dev_login_enabled && <><p className="warning">DEV/TEST · SIMULIERTER TESTPRINCIPAL · ausschließlich Entwicklungsanmeldung, kein Produktionslogin und kein menschlicher Produktions-Freigabenachweis.</p><CredentialsForm local={false} onLogin={onLogin}/></>}
{!config.oidc_configured && !config.dev_login_enabled && !config.local_login_enabled && <p className="warning">Anmeldung: not_configured · Administrator kontaktieren.</p>}
</>}
</main>;
}
+2 -1
View File
@@ -1,4 +1,5 @@
import { ScriptLibrary } from './script-library';
import { McpTokenManagement } from './mcp-token-management';
import { CatalogCheckNotice } from './catalog-check';
import React, { useEffect, useState } from 'react';
import { createRoot } from 'react-dom/client';
@@ -297,7 +298,7 @@ function Workspace({ auth, logout }: { auth: Session; logout: () => void }) {
}
function TenantWorkspace({ tenantId, auth }: { tenantId: string; auth: Session }) {
const [selected, setSelected] = useState<string[]>([]), [planId, setPlan] = useState<string | null>(null), [operationId, setOperation] = useState<string | null>(null);
return <><Devices tenantId={tenantId} auth={auth} selected={selected} setSelected={setSelected}/><ScriptLibrary tenantId={tenantId} auth={auth} selected={selected} showPlan={setPlan}/><Planner tenantId={tenantId} auth={auth} selected={selected} showPlan={setPlan}/><Catalog tenantId={tenantId} auth={auth}/><WindowsMsiCatalog tenantId={tenantId} auth={auth}/><AgentReleaseCatalog tenantId={tenantId} auth={auth}/><TenantControls tenantId={tenantId} auth={auth}/><Operations tenantId={tenantId} open={setOperation}/>{operationId && <OperationDetail key={operationId} tenantId={tenantId} id={operationId} auth={auth} openPlan={setPlan}/ >}{planId && <PlanDetail key={planId} tenantId={tenantId} id={planId} auth={auth} onOperation={setOperation}/>}</>;
return <><Devices tenantId={tenantId} auth={auth} selected={selected} setSelected={setSelected}/><ScriptLibrary tenantId={tenantId} auth={auth} selected={selected} showPlan={setPlan}/><Planner tenantId={tenantId} auth={auth} selected={selected} showPlan={setPlan}/><Catalog tenantId={tenantId} auth={auth}/><WindowsMsiCatalog tenantId={tenantId} auth={auth}/><AgentReleaseCatalog tenantId={tenantId} auth={auth}/><TenantControls tenantId={tenantId} auth={auth}/><McpTokenManagement tenantId={tenantId} auth={auth}/><Operations tenantId={tenantId} open={setOperation}/>{operationId && <OperationDetail key={operationId} tenantId={tenantId} id={operationId} auth={auth} openPlan={setPlan}/ >}{planId && <PlanDetail key={planId} tenantId={tenantId} id={planId} auth={auth} onOperation={setOperation}/>}</>;
}
function App() {
const [auth, setAuth] = useState<Session | null>(null), [loading, setLoading] = useState(true), [error, setError] = useState<string | null>(null);
+54
View File
@@ -0,0 +1,54 @@
import { describe, expect, it } from 'vitest';
import { renderToStaticMarkup } from 'react-dom/server';
import { type Session } from './api';
import { canManageMcpTokens, McpTokenManagement, mcpToken, mcpTokenDraft, mcpTokenListing } from './mcp-token-management';
const now = Date.parse('2026-11-17T12:00:00Z');
const auth: Session = { principal: { id: 'test-human', display_name: 'Test', simulated: false },
tenants: [{ tenant_id: 'tenant-a', name: 'Tenant' }], csrf_token: 'test-csrf', permissions: ['tokens:manage', 'inventory:read'] };
const metadata = { token_id: '11111111-1111-4111-8111-111111111111', name: 'Test client', principal: 'test-human',
scopes: ['inventory:read'], created_at: '2026-11-17T12:00:00Z', expires_at: '2026-12-17T12:00:00Z', last_used_at: null, revoked_at: null };
describe('MCP token management', () => {
it('requires a real session with management permission and matching tenant', () => {
expect(canManageMcpTokens(auth, 'tenant-a')).toBe(true);
for (const session of [
{ ...auth, principal: { ...auth.principal, simulated: true } }, { ...auth, csrf_token: '' },
{ ...auth, permissions: ['approvals:approve'] }, { ...auth, tenants: [] }, { ...auth, permissions: undefined },
]) {
expect(canManageMcpTokens(session, 'tenant-a')).toBe(false);
expect(renderToStaticMarkup(<McpTokenManagement auth={session} tenantId="tenant-a"/>)).toBe('');
}
expect(renderToStaticMarkup(<McpTokenManagement auth={auth} tenantId="tenant-b"/>)).toBe('');
expect(renderToStaticMarkup(<McpTokenManagement auth={auth} tenantId="tenant-a"/>)).toContain('MCP-Tokens');
});
it('projects metadata independently from an accidentally repeated secret', () => {
expect(mcpToken({ ...metadata, token: 'synthetic-must-not-enter-list-state', private_key: 'synthetic' })).toEqual(metadata);
expect(() => mcpToken({ ...metadata, expires_at: 'tomorrow' })).toThrow();
expect(() => mcpToken({ ...metadata, last_used_at: undefined })).toThrow();
});
it('requires read-only defaults and exact declared available rights', () => {
const listing = { tokens: [metadata], allowed_scopes: ['inventory:read', 'operations:submit'], default_scopes: ['inventory:read'] };
expect(mcpTokenListing(listing).default_scopes).toEqual(['inventory:read']);
for (const altered of [
{ ...listing, default_scopes: ['operations:submit'] }, { ...listing, default_scopes: ['logs:read'] },
{ ...listing, allowed_scopes: ['approvals:approve'] }, { ...listing, allowed_scopes: ['tokens:manage'] },
{ ...listing, allowed_scopes: ['inventory:read', 'inventory:read'] }, { ...listing, tokens: [metadata, metadata] },
]) expect(() => mcpTokenListing(altered)).toThrow();
});
it('binds creation to explicit current rights and a finite expiry', () => {
expect(mcpTokenDraft(' Client ', ['inventory:read'], ['inventory:read'], metadata.expires_at, now)).toEqual({
name: 'Client', scopes: ['inventory:read'], expires_at: '2026-12-17T12:00:00.000Z',
});
for (const selected of [[], ['inventory:read', 'inventory:read'], ['system:execute'], ['approvals:approve'], ['tokens:manage']]) {
expect(() => mcpTokenDraft('Client', selected, ['inventory:read'], metadata.expires_at, now)).toThrow();
}
for (const expires of ['invalid', new Date(now).toISOString(), new Date(now + 366 * 86400000).toISOString()]) {
expect(() => mcpTokenDraft('Client', ['inventory:read'], ['inventory:read'], expires, now)).toThrow();
}
expect(mcpTokenDraft('🙂'.repeat(120), ['inventory:read'], ['inventory:read'], metadata.expires_at, now).name).toHaveLength(240);
expect(() => mcpTokenDraft('Client\u0000', ['inventory:read'], ['inventory:read'], metadata.expires_at, now)).toThrow();
expect(() => mcpTokenDraft(' ', ['inventory:read'], ['inventory:read'], metadata.expires_at, now)).toThrow();
expect(() => mcpTokenDraft('x'.repeat(121), ['inventory:read'], ['inventory:read'], metadata.expires_at, now)).toThrow();
});
});
+220
View File
@@ -0,0 +1,220 @@
import { useEffect, useRef, useState, type FormEvent } from 'react';
import { ApiError, record, request, tenantPath, type Session } from './api';
const scopeLabels = {
'inventory:read': 'Inventar lesen',
'logs:read': 'Gespeicherte 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;
}
interface Listing { tokens: McpToken[]; allowed_scopes: Scope[]; default_scopes: Scope[] }
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);
return { 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);
return { tokens, allowed_scopes: allowed, default_scopes: defaults };
}
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;
}
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 [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 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); }
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 });
setListing(current => current && { ...current, tokens: [metadata, ...current.tokens] });
setName(''); 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.'); }
}
return <section aria-label="MCP-Tokens">
<h2>MCP-Tokens</h2>
<p>Erstellen Sie einen Zugang für Ihren MCP-Client. Skript- und Wartungsaufträge benötigen weiterhin die Genehmigung in der WebUI.</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> : <>
<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>
<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} type="submit">Token erstellen</button>
</fieldset>
{listing.allowed_scopes.length === 0 && <p>Ihre Mitgliedschaft bietet keine Rechte für ein MCP-Token.</p>}
</form>
<h3>Ausgestellte Tokens</h3>
<button type="button" disabled={busy} onClick={() => { setError(''); setReload(value => value + 1); }}>Tokenliste aktualisieren</button>
{!listing.tokens.length ? <p>Es wurden noch keine Tokens erstellt.</p> : <div className="table"><table>
<thead><tr><th>Name und ID</th><th>Rechte</th><th>Erstellt und zuletzt verwendet</th><th>Gültigkeit</th><th>Verwaltung</th></tr></thead>
<tbody>{listing.tokens.map(token => <tr key={token.token_id}>
<td>{token.name}<small><code>{token.token_id}</code></small><small>{token.principal}</small></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>{token.revoked_at === null && (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>;
}