import { ScriptLibrary } from './script-library';
import { CatalogCheckNotice } from './catalog-check';
import React, { useEffect, useState } from 'react';
import { createRoot } from 'react-dom/client';
import { actions, Action, ApiError, authConfig, approvalBlockers, expectedStdout, objectId, page, Page, PlanInput, pretty, record, RecordValue, request, session, Session, stringField, tenant, tenantPath, validateInput, windowsPowerShellRemoteSignedProfile, fullMaintenanceScriptProfile } from './api';
import './style.css';
import { AdminControl, Catalog, TenantControls } from './management';
import { allowed, availableActions, parseStrictJson, powerShellApprovalBlockers, powerShellPlanJobs, rootWarning, systemWarning, systemPlanJobs, validateSensitiveInput, verifyPlanIntegrity, queryLogsApprovalBlockers, queryLogsPlanJobs, windowsMsiApprovalBlockers, windowsMsiPlanJobs, verifyWindowsMsiManifest, fullMaintenanceWarning } from './safety';
import { RecoveryReview, recoveryAsset, recoveryTenant } from './recovery-review';
import { EchoProbeReview } from './echo-probe-review';
import { EchoCompletionReview } from './echo-completion-review';
import { SyncAlignmentReview } from './sync-alignment-review';
import { SystemNonstartReview } from './system-nonstart-review';
import { Login } from './login';
import { ConsoleOutput, outputText } from './console-output';
import { scriptApprovalBlockers, scriptPlanJobs, verifyScriptPlan } from './script-console';
import { agentUpdateWarning, agentUpdatePlanJobs, agentUpdateApprovalBlockers, verifyAgentUpdatePlan, verifyReleaseMetadata, releaseEnvelope, uploadAgentUpdateArtifact } from './agent-updates';
const errorText = (error: unknown) => error instanceof Error ? error.message : 'Unbekannter Fehler';
export function JsonView({ value, label = 'Vollständige Daten' }: { value: unknown; label?: string }) { return {label} {pretty(value)} ; }
export function AgentUpdatePlanNotice({ plan }: { plan: RecordValue }) {
try {
const jobs = agentUpdatePlanJobs(plan); if (!jobs.length) return null;
return Vollständige feste Agent-Selbstupdates ({jobs.length}) {agentUpdateWarning}
{jobs.map(job => Asset {job.assetId} Agent: {job.agentId} · Job: {job.jobId} · Versuch: {job.attemptId} · Identität: {job.identity}
Release: {String(job.manifest.release_id)} · Version: {String(job.manifest.version)} · Plattform: {String(job.manifest.platform)} · Sequenz: {String(job.manifest.release_sequence)}
Manifest-SHA256: {String(job.update.manifest_sha256)} · Job-SHA256: {job.jobHash}
Die folgenden Vorgänger-, Codepaar-, Updater-, Keyring- und Peerpinbindungen stammen vollständig aus den unveränderten gespeicherten Planbytes. Gesamtbudget600s, Healthfrist180s; keine allgemeine Reparatur oder neue Freigabe.
)}
;
} catch { return Agentupdateplan nicht vollständig aus unveränderten Originalbytes verifiziert. Keine Genehmigung möglich. ; }
}
export function ScriptPlanNotice({ plan }: { plan: RecordValue }) {
try {
const jobs = scriptPlanJobs(plan); if (!jobs.length) return null;
return Vollständige feste Skriptaufträge ({jobs.length}) Diese Inhalte stammen aus den hashgeprüften gespeicherten Planbytes. Jeder Zielauftrag, Versuch und Skripthash ist fest gebunden.
{jobs.map(job => Asset {job.assetId} Agent: {job.agentId} · Job: {job.jobId} · Versuch: {job.attemptId}
{job.revision && Skriptbibliothek · {job.revision.name} · Version {job.revision.version} · {job.revision.id}
}
Interpreter: {job.interpreter} · Identität: {job.identity} · Privilegiertes Profil: {job.privilegedProfile === fullMaintenanceScriptProfile ? fullMaintenanceScriptProfile : 'bestehendes begrenztes Profil'} · Windowsprozess: {job.interpreter !== 'powershell' ? 'nicht zutreffend' : job.windowsProfile === 'powershell_51_remote_signed' ? 'Windows PowerShell5.1 RemoteSigned, nur Jobprozess' : 'geerbte Windowsrichtlinie / kein Windows-Prozessoverride'}
Frühester Start: {job.notBefore} · Startfrist: {job.startBefore} · Laufzeit: {job.runtimeSeconds}s · Ausgabe: höchstens {job.outputBytes} Bytes
Skript: {job.scriptBytes} UTF-8-Bytes · SHA256: {job.scriptHash} Jobpayload-SHA256: {job.jobHash}
{job.privilegedProfile === fullMaintenanceScriptProfile ? {fullMaintenanceWarning}
: job.identity === 'root' && {rootWarning}
}
Vollständiger Skripttext; Steuerzeichen, BOM und CR werden sichtbar als \uXXXX dargestellt. LF bleibt Zeilenumbruch. Kein Kürzen oder Normalisieren der gespeicherten Bytes.
{outputText(new TextEncoder().encode(job.script)).text}
Feste Argumente (JSON): {JSON.stringify(job.arguments)}
stdout-Nachbedingung (JSON): {JSON.stringify(job.expectedStdout)}{job.expectedStdout === null && ' · keine zusätzliche fachliche stdout-Prüfung gebunden'}
)}
;
} catch { return Skriptplan ist nicht vollständig aus unveränderten gespeicherten Bytes verifiziert. Keine Genehmigung möglich. ; }
}
export function SystemPlanNotice({ plan }: { plan: RecordValue }) {
let jobs: RecordValue[];
try { jobs = systemPlanJobs(plan).filter(p => record(p.action).action === 'set_service_state'); }
catch { return Gespeicherte Planbytes sind nicht lesbar. Keine verlässliche SYSTEM-Plananzeige; Genehmigungsverifikation muss erfolgreich sein. ; }
if (!jobs.length) return null;
return {systemWarning}
{jobs.map((payload, i) => { const action = record(payload.action); return Identität: system · Asset: {String(payload.asset_id)} · Dienst: {String(action.unit)} · Zielzustand: {String(action.state)} ; })} Diese Definitionen stammen aus den gespeicherten Planbytes; die vollständigen Zielpayloads und Hashes stehen darunter.
;
}
export function WindowsRebootPlanNotice({ plan }: { plan: RecordValue }) {
try {
const jobs = systemPlanJobs(plan).filter(p => record(p.action).action === 'reboot');
if (!jobs.length) return null;
return Geplanter Windows-Neustart als SYSTEM
Der Agent kündigt den lokalen Neustart fünf Sekunden vorher an und erzwingt kein Schließen von Anwendungen. Erfolg benötigt einen authentisierten Wiederkontakt mit neuer Boot-ID innerhalb der festen 180 Sekunden ab zentraler Startreservierung. Bei unklarer Wirkung erfolgt kein automatischer weiterer Neustart.
{jobs.map((p, i) => Asset: {String(p.asset_id)} · Job: {String(p.job_id)} · Versuch: {String(p.attempt_id)} · Grund: {String(record(p.action).reason)} )}
;
} catch { return Windows-Neustartplan ist nicht aus unveränderten gespeicherten Bytes verifiziert. ; }
}
export function WindowsMsiPlanNotice({ plan }: { plan: RecordValue }) {
try {
const jobs = windowsMsiPlanJobs(plan); if (!jobs.length) return null;
return {systemWarning}
Windows · SYSTEM · Machine · x64 · feste MSI-Profile, keine freie Installer-URL/Argumente. Diese Definition stammt ausschließlich aus hashgeprüften gespeicherten Planbytes.
{jobs.map((job, i) =>
Asset: {job.assetId} · Rezept: {job.recipeId} · Rezept-SHA256: {job.recipeHash}
Artefakt: {job.artifactId} · SHA256: {job.artifactHash} · {job.artifactBytes} Bytes
ProductCode: {job.productCode} · UpgradeCode: {job.upgradeCode} · Version: {job.version} · PackageCode: {job.packageCode ?? 'im historischen1.0-Rezept nicht separat gebunden; vollständiger Artefakthash bleibt fest'}
Nutzdatei: {job.payloadPath} · SHA256: {job.payloadHash} · {job.payloadBytes} Bytes
Vorgänger: {job.predecessor ? `${job.predecessor.product_code} · ${job.predecessor.product_version} · ${job.predecessor.payload_path} · SHA256 ${job.predecessor.payload_sha256} · ${job.predecessor.payload_bytes} Bytes` : 'keine Upgrade-Reparatur; erste1.0-Installation oder separat belegter Noop'}
Fester Aufruf: %SystemRoot%\System32\msiexec.exe {job.arguments.map(arg => JSON.stringify(arg)).join(' ')}
No-Reboot: true · ursprüngliches Gesamtbudget: {job.runtimeSeconds}s · Ausgabelimit: {job.outputBytes} Bytes
)} Upgrade1.1 setzt den exakten1.0-Vorgänger voraus und entfernt ihn. Erfolg/Noop benötigen unabhängige rechtzeitige Nachbedingungen.3010 meldet Neustartbedarf ohne Neustart;1641/unklare Wirkung bleiben unknown,1618 Konflikt ohne Retry. Planung und Anzeige behaupten keine native Installer-/Clock-/Helperbereitschaft.
;
} catch { return MSI-Plan ist nicht verifiziert oder wurde verändert. Keine Genehmigung ohne unveränderte gespeicherte Planbytes. ; }
}
export function PowerShellPlanNotice({ plan }: { plan: RecordValue }) {
try {
const jobs = powerShellPlanJobs(plan);
if (!jobs.length) return null;
return Diese Ausführungsoptionen sind an die hashgeprüften gespeicherten Planbytes gebunden.
{jobs.map((job, i) => Asset: {job.assetId} · Windows PowerShell5.1 · {job.identity ?? 'agent_service'} · {job.profile === windowsPowerShellRemoteSignedProfile ? 'RemoteSigned · nur Jobprozess' : 'Geerbte Richtlinie · kein ExecutionPolicy-Prozessparameter'} )} Keine Maschinen-/CurrentUser-/GPO-Änderung durch den Executor. GPO-Vorgaben bleiben wirksam; die angeforderte Option ist kein Nachweis der effektiven Policy.
;
} catch { return PowerShell-Planprofil ist nicht verifiziert oder wurde verändert. Keine Genehmigung ohne gültige gespeicherte Planbytes. ; }
}
export function QueryLogsPlanNotice({ plan }: { plan: RecordValue }) {
try {
const jobs = queryLogsPlanJobs(plan);
if (!jobs.length) return null;
return UI-genehmigte Liveabfrage aus hashgeprüften gespeicherten Planbytes; kein passives Inventar, keine automatische Erhebung.
{jobs.map((job, i) => Asset: {job.assetId} · Quelle: {job.source}{job.windows ? <> · Kanal: {job.channel} · Provider: {job.provider} · agent_service> : ' · Linux-Journal'} · UTC-Fenster: [{job.since}, {job.until}) · maximal {job.maxLines} {job.windows ? 'Events' : 'Zeilen'} · {job.outputBytes} Bytes · äußere Joblaufzeit {job.runtimeSeconds}s{job.windows && ' · inneres Abfragebudget höchstens5000ms, zwischen Win32-Aufrufen kooperativ geprüft'} )} Grenzen, Abbruch, fehlende Rechte und Teilabdeckung bleiben sichtbar. Keine Bookmarkfortschreibung durch diesen Auftrag; die Abfrage behauptet keine vollständige Sammlung aller Systemlogs.
;
} catch { return Logfenster ist nicht verifiziert oder wurde verändert. Keine Genehmigung ohne gültige gespeicherte Planbytes. ; }
}
function ErrorBox({ error }: { error: string | null }) { return error ?
{error}
: null; }
function useResource(load: (signal: AbortSignal) => Promise, deps: React.DependencyList, poll = false) {
const [data, setData] = useState(null), [error, setError] = useState(null), [revision, setRevision] = useState(0);
useEffect(() => {
let active = true; const controller = new AbortController(); let timer: ReturnType | undefined;
setData(null); setError(null);
const run = async () => { try { const result = await load(controller.signal); if (active) { setData(result); setError(null); } } catch (e) { if (active) setError(errorText(e)); }
finally { if (active && poll) timer = setTimeout(run, 4000); } };
void run(); return () => { active = false; controller.abort(); clearTimeout(timer); };
}, [...deps, revision]);
return { data, error, reload: () => setRevision(v => v + 1) };
}
function PageStatus({ data }: { data: Page }) { return Listenstand: {data.as_of} · Vollständigkeit: {data.completeness} · begrenzt: {String(data.truncated)}. Fehlende Einträge sind kein Löschungsnachweis.
; }
function Age({ value }: { value: unknown }) { const ms = typeof value === 'string' ? Date.parse(value) : NaN; return {Number.isFinite(ms) ? `${Math.max(0, Math.floor((Date.now() - ms) / 1000))} s` : 'unknown'} ; }
function Devices({ tenantId, auth, selected, setSelected }: { tenantId: string; auth: Session; selected: string[]; setSelected: (ids: string[]) => void }) {
const [cursor, setCursor] = useState(null), [asset, setAsset] = useState(null);
const list = useResource(async signal => page(await request(tenantPath(tenantId, `/devices${cursor ? `?cursor=${encodeURIComponent(cursor)}` : ''}`), { signal })), [tenantId, cursor], true);
const detail = useResource(async signal => asset ? record(await request(tenantPath(tenantId, `/devices/${encodeURIComponent(asset)}`), { signal })) : null, [tenantId, asset], true);
return Geräte und gespeichertes Inventar Präsenz, Datenfrische und fachliche Gesundheit sind unabhängig. „unreachable“ bedeutet nicht „ausgeschaltet“.
{!list.data ? Lade Geräte …
: <>Fest auswählen Gerät / Asset-ID Präsenz / Gesundheit Quelle / Qualität Erhebung / Alter / Empfang {list.data.items.map(d => { const id = objectId(d, 'asset'); return setSelected(e.target.checked ? [...selected, id] : selected.filter(v => v !== id))}/> setAsset(id)}>{typeof d.hostname === 'string' ? d.hostname : id} {id} {stringField(d, 'presence')} / {stringField(d, 'health')}Kontakt: {stringField(d, 'last_contact_at')} {stringField(d, 'source_id')} / {stringField(d, 'quality')}{stringField(d, 'completeness')} {stringField(d, 'observed_at')}Alter: · empfangen: {stringField(d, 'received_at')} ; })}
{!list.data.items.length && Keine sichtbaren Geräte in diesem Listenabschnitt.
} setCursor(null)}>Erste Seite setCursor(list.data?.next_cursor ?? null)}>Nächste Seite >}
Fester Auswahlsnapshot ({selected.length}): {selected.join(', ') || 'keine Ziele'}
{asset && Inventardetail {asset} {detail.data && <> >} }
{tenantId === recoveryTenant && asset === recoveryAsset && allowed(auth, 'inventory:read') &&
<>>}
;
}
const initialParameters: Record = {
run_script: {}, refresh_inventory: { scope: 'linux.base' }, query_logs: { unit: '', since: '', until: '', max_lines: 1000 }, set_service_state: { unit: '', state: 'running' }, ensure_package: { provider: 'apt', recipe_version: '', package: '', version: '', architecture: 'amd64', installation_context: 'system', apt_manifest: null }, apply_updates: { provider: 'apt', packages: [], reboot_policy: 'never', apt_manifest: null }, reboot: { reason: '', dependency_group: '', reconnect_timeout_seconds: 300 }, apt_native_acceptance: { recipe_id: 'rmm-apt-fixture-install-1.0', recipe_version: '1', apt_manifest: null },
update_agent: { release_id: '' },
};
function Planner({ tenantId, auth, selected, showPlan }: { tenantId: string; auth: Session; selected: string[]; showPlan: (id: string) => void }) {
const [scriptPlatform, setScriptPlatform] = useState('linux'), [mixedVariants, setMixedVariants] = useState('[]');
const [action, setAction] = useState('run_script'), [parameters, setParameters] = useState('{}'), [error, setError] = useState(null), [busy, setBusy] = useState(false);
const [identity, setIdentity] = useState('agent_service');
return Neuen unveränderlichen Plan vorbereiten Nur fest ausgewählte Asset-IDs. Keine Ausführung durch Planung oder Antrag; jede Aktion einschließlich Live-Inventar benötigt Genehmigung.
;
}
function localDate(date: Date) { return new Date(date.getTime() - date.getTimezoneOffset() * 60000).toISOString().slice(0, 16); }
function WindowsMsiCatalog({ tenantId, auth }: { tenantId: string; auth: Session }) {
const [source, setSource] = useState('{}'), [cursor, setCursor] = useState(null), [revision, setRevision] = useState(0), [error, setError] = useState(null), [busy, setBusy] = useState(false), [receipt, setReceipt] = useState(null);
const list = useResource(async signal => {
const result = page(await request(tenantPath(tenantId, `/windows-msi-recipes${cursor ? `?cursor=${encodeURIComponent(cursor)}` : ''}`), { signal }));
const items: RecordValue[] = [];
for (const item of result.items) { const manifest = await verifyWindowsMsiManifest(item.manifest); if (item.sha256 !== manifest.recipe_sha256 || item.recipe_id !== manifest.recipe.recipe_id) throw new Error('MSI-Katalogansicht widerspricht Rezeptbytes'); items.push({ catalog_id: item.catalog_id, recipe_id: manifest.recipe.recipe_id, sha256: manifest.recipe_sha256, manifest }); }
return { ...result, items };
}, [tenantId, cursor, revision]);
return Getrennter unveränderlicher Windows-MSI-Katalog Nur die zwei festen eigenen Machine/x64-Rezepte. Import ist Metadatenpflege mit catalog:write, keine Genehmigung, Installation oder Capabilityfreigabe. Öffentliche MSI-Artefakte werden über den bestehenden Artefaktimport gebunden. Vollständiges geprüftes Manifest für den Parametereditor kopieren.
{list.data && <> setCursor(null)}>Erste MSI-Rezeptseite setCursor(list.data?.next_cursor ?? null)}>Nächste MSI-Rezeptseite >}
Neues festes MSI-Manifest importieren { event.preventDefault(); setBusy(true); setError(null); setReceipt(null); try {
if (!allowed(auth, 'catalog:write')) throw new Error('catalog:write unbekannt/nicht erteilt');
const manifest = await verifyWindowsMsiManifest(parseStrictJson(source));
const result = record(await request(tenantPath(tenantId, '/windows-msi-recipes'), { body: manifest, csrf: auth.csrf_token }));
const stored = await verifyWindowsMsiManifest(result.manifest);
if (result.sha256 !== manifest.recipe_sha256 || result.recipe_id !== manifest.recipe.recipe_id || JSON.stringify(stored) !== JSON.stringify(manifest)) throw new Error('MSI-Importbeleg widerspricht unveränderlichen Rezeptbytes');
setReceipt({ catalog_id: result.catalog_id, manifest: stored }); setRevision(n => n + 1);
} catch (error) { setError(errorText(error)); } finally { setBusy(false); } }}>Vollständiges MSI-Manifest JSON setSource(e.target.value)} spellCheck={false}/> Festes MSI-Manifest importieren · keine Ausführung {receipt !== null && }
;
}
function AgentReleaseCatalog({ tenantId, auth }: { tenantId: string; auth: Session }) {
const [cursor, setCursor] = useState(null), [revision, setRevision] = useState(0), [source, setSource] = useState('{}'), [busy, setBusy] = useState(false), [error, setError] = useState(null), [receipts, setReceipts] = useState([]);
const [enrollment, setEnrollment] = useState<{ token: string; expires: string; origin: string | null; platforms: string[] } | null>(null);
const [enrollmentError, setEnrollmentError] = useState(null);
const [issuing, setIssuing] = useState(false);
const list = useResource(async signal => {
const result = page(await request(tenantPath(tenantId, `/agent-releases${cursor ? `?cursor=${encodeURIComponent(cursor)}` : ''}`), { signal }));
const items: RecordValue[] = [];
for (const item of result.items) { const release = await verifyReleaseMetadata(item.release_envelope, item.manifest_sha256); if (item.release_id !== release.manifest.release_id) throw new Error('Release-ID widerspricht originalem Manifest'); items.push({ release_id: item.release_id, manifest_sha256: item.manifest_sha256, manifest: release.manifest, signature_and_time_valid: item.signature_and_time_valid === true }); }
return { ...result, items };
}, [tenantId, cursor, revision]);
return Signierter Agent-Releasekatalog Installierte Clients können hier veröffentlichte Versionen beim nächsten regulären Abruf beziehen. Jedes signierte Manifest bindet eine Plattform sowie die genauen Agent- und Helperdateien.
{list.data && <> setCursor(null)}>Erste Releaseseite setCursor(list.data?.next_cursor ?? null)}>Nächste Releaseseite >}
Signiertes festes Release mit Agent und Helper veröffentlichen Der Server prüft Signatur, Größe und SHA-256 beider Dateien. Erst nach dem vollständigen Upload wird die neue Version für Geräte sichtbar.
{ event.preventDefault(); setBusy(true); setError(null); setReceipts([]); const form = new FormData(event.currentTarget); try {
if (!allowed(auth, 'catalog:write')) throw new Error('catalog:write unbekannt/nicht erteilt');
const release = releaseEnvelope(parseStrictJson(source)), artifacts = release.manifest.artifacts as RecordValue[];
const files = [form.get('agent_file'), form.get('helper_file')];
if (files.some((file, index) => !(file instanceof File) || file.size !== artifacts[index]!.bytes)) throw new Error('Beide Dateien müssen die exakten Manifestlängen haben');
for (let index = 0; index < 2; index++) { const receipt = await uploadAgentUpdateArtifact(tenantId, artifacts[index]!, files[index] as File, auth.csrf_token); setReceipts(previous => [...previous, receipt]); }
const result = record(await request(tenantPath(tenantId, '/agent-releases'), { body: release.envelope, csrf: auth.csrf_token }));
const published = await verifyReleaseMetadata(result.release_envelope, result.manifest_sha256);
if (published.manifest.release_id !== release.manifest.release_id || JSON.stringify(published.envelope) !== JSON.stringify(release.envelope)) throw new Error('Veröffentlichung widerspricht festem Release');
setReceipts(previous => [...previous, { release_id: published.manifest.release_id, manifest_sha256: result.manifest_sha256 }]); setRevision(n => n + 1);
} catch (error) { setError(errorText(error)); } finally { setBusy(false); } }}>
Vollständiger signierter Release-Envelope JSON setSource(e.target.value)} spellCheck={false}/>
Exakte Agentdatei Exakte Helperdatei
Release für Clients veröffentlichen {receipts.length > 0 && }
{ if (!event.currentTarget.open) setEnrollment(null); }}>
Neues Gerät aufnehmen
Das HTTPS-Installationsskript fragt auf dem Gerät nach dem Einmalcode. Er gilt für den ausgewählten Mandanten und läuft nach 15 Minuten ab.
{
setIssuing(true); setEnrollment(null); setEnrollmentError(null);
try {
const result = record(await request(tenantPath(tenantId, '/enrollment-tokens'), { body: {}, csrf: auth.csrf_token }));
if (typeof result.token !== 'string' || !/^[a-f0-9]{64}$/.test(result.token) || typeof result.expires_at !== 'string') throw new Error('Ungültiger Einmalcode');
setEnrollment({ token: result.token, expires: result.expires_at, origin: typeof result.bootstrap_origin === 'string' ? new URL(result.bootstrap_origin).origin : null,
platforms: Array.isArray(result.release_platforms) ? result.release_platforms.filter((p): p is string => typeof p === 'string') : [] });
} catch (error) { setEnrollmentError(errorText(error)); } finally { setIssuing(false); }
}}>Einmalcode erstellen
{enrollment && <>Einmalcode gültig bis {new Date(enrollment.expires).toLocaleString()} setEnrollment(null)}>Code ausblenden
{enrollment.origin && enrollment.platforms.includes('x86_64-unknown-linux-gnu') && <>Linux, mit einem Administratorkonto ausführen
{`curl --fail --show-error --silent '${enrollment.origin}/install/linux.sh' -o linux.sh && sudo sh linux.sh '${enrollment.origin}'`} >}
{enrollment.origin && ['x86_64-pc-windows-msvc','x86_64-pc-windows-gnu'].filter(p => enrollment.platforms.includes(p)).map(platform =>
Windows {platform.endsWith('-gnu') ? 'GNU (Entwicklungsrelease)' : 'MSVC'}, in einer administrativen Windows PowerShell ausführen
{`Invoke-WebRequest -UseBasicParsing '${enrollment.origin}/install/windows.ps1' -OutFile .\\windows.ps1
.\\windows.ps1 -BootstrapBase '${enrollment.origin}' -Platform '${platform}'`} )}
>}
;
}
function PlanDetail({ tenantId, id, auth, onOperation }: { tenantId: string; id: string; auth: Session; onOperation: (id: string) => void }) {
const plan = useResource(async signal => { const result = record(await request(tenantPath(tenantId, `/operation-plans/${encodeURIComponent(id)}`), { signal })); await verifyPlanIntegrity(result); await verifyScriptPlan(result); await verifyAgentUpdatePlan(result); return result; }, [tenantId, id]);
const [error, setError] = useState(null), [busy, setBusy] = useState(false), [confirmed, setConfirmed] = useState(false), [submitted, setSubmitted] = useState(false), [pending, setPending] = useState(false);
const [idempotency] = useState(() => crypto.randomUUID());
const blockers = plan.data ? [...approvalBlockers(plan.data), ...powerShellApprovalBlockers(plan.data), ...queryLogsApprovalBlockers(plan.data), ...windowsMsiApprovalBlockers(plan.data), ...scriptApprovalBlockers(plan.data), ...agentUpdateApprovalBlockers(plan.data)] : ['Plan noch nicht geladen'];
const recheck = async () => { if (!plan.data) throw new Error('Plan fehlt'); await verifyPlanIntegrity(plan.data); await verifyScriptPlan(plan.data); await verifyAgentUpdatePlan(plan.data); const errors = [...approvalBlockers(plan.data), ...powerShellApprovalBlockers(plan.data), ...queryLogsApprovalBlockers(plan.data), ...windowsMsiApprovalBlockers(plan.data), ...scriptApprovalBlockers(plan.data), ...agentUpdateApprovalBlockers(plan.data)]; if (errors.length) throw new Error(errors.join('; ')); };
return Unveränderlicher Plan / Genehmigungsdetail {plan.data && <>
Plan-ID: {id}
Exakter gespeicherter Planhash: {stringField(plan.data, 'plan_hash')}
Feste Ziele: {Array.isArray(plan.data.resolved_targets) ? plan.data.resolved_targets.length : 'unknown'}. Die folgenden Zielpreviews sind unveränderliche Plandefinitionen, keine ausführbaren Jobs oder angelegten Versuche. Diese entstehen erst nach Genehmigung.
Genehmigung bindet ausschließlich diesen unveränderlichen Plan. Kein pauschaler Retry, keine Wildcard, kein impliziter Reboot. Unbekannte Wirkung wird nicht automatisch wiederholt. Ein Exitcode allein beweist keine fachliche Wirkung.
{blockers.length > 0 && Nicht genehmigungsfähig: {blockers.join('; ')}
}
0 || submitted} onClick={async () => { setBusy(true); setError(null); try { await recheck(); const result = record(await request(tenantPath(tenantId, `/operation-plans/${encodeURIComponent(id)}/submit`), { csrf: auth.csrf_token, body: { idempotency_key: idempotency } })); setSubmitted(true); setPending((result.approval_state ?? result.state) === 'pending_approval'); onOperation(objectId(result, 'operation')); } catch (e) { setError(errorText(e)); } finally { setBusy(false); } }}>Antrag absenden · pending_approval
setConfirmed(e.target.checked)}/>Ich habe sämtliche festen Ziele, Aktionen, Bytes/Hashes, Zielpreviews, Ausführungsprofile/Prozessumfänge und Auswirkungen dieses Plans geprüft.
0 || !(pending || plan.data.approval_state === 'pending_approval')} onClick={async () => { setBusy(true); setError(null); try {
await recheck(); const result = record(await request(tenantPath(tenantId, `/operation-plans/${encodeURIComponent(id)}/authorizations`), { csrf: auth.csrf_token, body: { plan_hash: plan.data?.plan_hash } })); setConfirmed(false); setPending(false); onOperation(objectId(result, 'operation')); plan.reload();
} catch (e) { setError(errorText(e)); } finally { setBusy(false); } }}>{auth.principal.simulated ? 'SIMULIERT: Diesen festen Plan ausdrücklich genehmigen' : 'Diesen festen Plan ausdrücklich genehmigen'}
Nur für einen bestehenden Antrag pending_approval; Server prüft interaktive Sitzung, Rechte, Tenant, Policy und Frist erneut. Keine automatische Genehmigung.
>} ;
}
function Operations({ tenantId, open }: { tenantId: string; open: (id: string) => void }) {
const [cursor, setCursor] = useState(null);
const list = useResource(async signal => page(await request(tenantPath(tenantId, `/operations${cursor ? `?cursor=${encodeURIComponent(cursor)}` : ''}`), { signal })), [tenantId, cursor], true);
return Anträge und Ausführungen {list.data && <>{list.data.items.map(o => open(objectId(o, 'operation'))}>{objectId(o, 'operation')} · Antrag: {stringField(o, 'approval_state')} · Ausführung: {stringField(o, 'execution_state')} )} {!list.data.items.length && Keine sichtbaren Anträge in diesem Listenabschnitt.
} setCursor(null)}>Erste Seite setCursor(list.data?.next_cursor ?? null)}>Nächste Seite >} ;
}
function OperationDetail({ tenantId, id, auth, openPlan }: { tenantId: string; id: string; auth: Session; openPlan: (id: string) => void }) {
const op = useResource(async signal => record(await request(tenantPath(tenantId, `/operations/${encodeURIComponent(id)}`), { signal })), [tenantId, id], true);
const [jobId, setJobId] = useState(null);
return Antrag / Ausführung {id} {op.data && <>
Antrag: {stringField(op.data, 'approval_state')} · Ausführung: {stringField(op.data, 'execution_state')}. pending_approval bedeutet keine ausführbaren Jobs. Teilzustände und unknown sind kein Gesamterfolg.
openPlan(objectId(op.data ?? {}, 'plan'))}>Unveränderlichen Plan zur Prüfung öffnen
{Array.isArray(op.data.jobs) && op.data.jobs.map(v => { const job = record(v); const jid = objectId(job, 'job'); return setJobId(jid)}>Job {jid} · {stringField(job, 'state')} ; })}
>}{jobId && } ;
}
function JobDetail({ tenantId, id, auth }: { tenantId: string; id: string; auth: Session }) {
const job = useResource(async signal => record(await request(tenantPath(tenantId, `/jobs/${encodeURIComponent(id)}`), { signal })), [tenantId, id], true);
const [error, setError] = useState(null), [busy, setBusy] = useState(false);
return Job {id} verifying = Nachprüfung läuft · unknown = Wirkung unklar, kein Retry · closed_unknown = von einem Menschen abgeschlossen, Wirkung weiterhin unbekannt, kein Retry · awaiting_reboot = Neustart oder Wiederanmeldung zur Nachprüfung ausstehend. Neue Neustartjobs benötigen eine eigene Genehmigung. cancel_requested ist kein bestätigter Abbruch, keine Rollbackzusage.
{job.data && <> >}
{ e.preventDefault(); const reason = new FormData(e.currentTarget).get('reason'); setBusy(true); setError(null); try { await request(tenantPath(tenantId, `/jobs/${encodeURIComponent(id)}/cancel`), { csrf: auth.csrf_token, body: { reason } }); job.reload(); } catch (e) { setError(errorText(e)); } finally { setBusy(false); } }}>Abbruchgrund Abbruch anfordern · nicht zurückrollen
{job.data && stringField(job.data, 'state') === 'unknown' && } ;
}
function UnknownClosure({ tenantId, id, job, auth, done }: { tenantId: string; id: string; job: RecordValue; auth: Session; done: () => void }) {
const [confirmed, setConfirmed] = useState(false), [reason, setReason] = useState(''), [busy, setBusy] = useState(false), [error, setError] = useState(null);
const eligible = allowed(auth, 'plans:approve') && !!auth.csrf_token;
return ;
}
function Workspace({ auth, logout }: { auth: Session; logout: () => void }) {
const tenants = useResource(async signal => page(await request('/api/v1/tenants', { signal })), []);
const [tenantId, setTenant] = useState(auth.tenants[0]?.tenant_id ?? ''), [error, setError] = useState(null);
const options = tenants.data?.items.map(tenant) ?? auth.tenants;
useEffect(() => { if (!tenantId && options[0]) setTenant(options[0].tenant_id); }, [options, tenantId]);
return <>
{auth.principal.simulated && SIMULIERT · dev/test-Testprincipal · Genehmigung ist eine Entwicklungs-Browsersimulation, kein menschlicher Produktions-Freigabenachweis. }
Mandant setTenant(e.target.value)}>Mandant wählen {options.map(t => {t.name} · {t.tenant_id} )} {tenantId && } >;
}
function TenantWorkspace({ tenantId, auth }: { tenantId: string; auth: Session }) {
const [selected, setSelected] = useState([]), [planId, setPlan] = useState(null), [operationId, setOperation] = useState(null);
return <>{operationId && }{planId && }>;
}
function App() {
const [auth, setAuth] = useState(null), [loading, setLoading] = useState(true), [error, setError] = useState(null);
const config = useResource(async signal => authConfig(await request('/auth/config', { signal })), []);
useEffect(() => { request('/auth/session').then(v => setAuth(session(v))).catch(e => { if (!(e instanceof ApiError && e.status === 401)) setError(errorText(e)); }).finally(() => setLoading(false)); }, []);
if (loading) return Sitzung wird geprüft … ;
return <>{auth ? <> { setAuth(null); setError(null); config.reload(); }}/>> : { setError(null); setAuth(s); }}/>}>;
}
class Boundary extends React.Component<{ children: React.ReactNode }, { error: string | null }> {
state: { error: string | null } = { error: null };
static getDerivedStateFromError(e: unknown) { return { error: errorText(e) }; }
render() { return this.state.error ? Darstellung blockiert Keine verlässliche Anzeige möglich. Nach Vertragskorrektur Seite neu laden.
: this.props.children; }
}
createRoot(document.getElementById('root')!).render( );