Files
rust-discovery/web/src/main.tsx
T

903 lines
72 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { actionTitle, ApprovalDecision, deviceName, display, Fact, identityName, OrderRows, orderTitle, PageButtons, Requester, Status, statusOf, statusText, targets, when } from './order-presentation';
import { Devices } from './devices';
import { CustomerManagement } from './customer-management';
import { ErrorBox, useResource, errorText } from './resource';
import { NavIcon, orderDetailRoute, type NavKey } from './navigation';
import { OrderComposer } from './order-composer';
import { ApprovalInbox, usePendingApprovals } from './approval-inbox';
import { ScriptLibrary } from './script-library';
import { McpTokenManagement } from './mcp-token-management';
import React, { useEffect, useRef, useState } from 'react';
import { createRoot } from 'react-dom/client';
import { actions, Action, ApiError, authConfig, approvalBlockers, expectedStdout, objectId, 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 { Login } from './login';
import { ConsoleOutput, visibleControls } from './console-output';
import { scriptApprovalBlockers, scriptPlanJobs, verifyScriptPlan } from './script-console';
import { agentUpdateWarning, agentUpdatePlanJobs, agentUpdateApprovalBlockers, verifyAgentUpdatePlan, verifyReleaseMetadata, releaseEnvelope, uploadAgentUpdateArtifact } from './agent-updates';
export function JsonView({ value, label = 'Vollständige Daten' }: { value: unknown; label?: string }) { return <details><summary>{label}</summary><pre aria-label={label}>{pretty(value)}</pre></details>; }
export function AgentUpdatePlanNotice({ plan }: { plan: RecordValue }) {
try {
const jobs = agentUpdatePlanJobs(plan); if (!jobs.length) return null;
return <article aria-label="Feste Agent-Selbstupdates vor Genehmigung"><h3>Vollständige feste Agent-Selbstupdates ({jobs.length})</h3><p className="warning">{agentUpdateWarning}</p>
{jobs.map(job => <article key={job.jobId}><h4>Asset {job.assetId}</h4><p>Agent: {job.agentId} · Job: {job.jobId} · Versuch: {job.attemptId} · Identität: <strong>{job.identity}</strong></p>
<p>Release: {String(job.manifest.release_id)} · Version: {String(job.manifest.version)} · Plattform: {String(job.manifest.platform)} · Sequenz: {String(job.manifest.release_sequence)}</p>
<p>Manifest-SHA256: <code>{String(job.update.manifest_sha256)}</code> · Job-SHA256: <code>{job.jobHash}</code></p>
<p>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.</p>
<JsonView value={job.update} label={`Vollständige feste Updatebindung für ${job.assetId}`}/>
</article>)}
</article>;
} catch { return <aside role="alert" className="error">Agentupdateplan nicht vollständig aus unveränderten Originalbytes verifiziert. Keine Genehmigung möglich.</aside>; }
}
export function ScriptPlanNotice({ plan }: { plan: RecordValue }) {
try {
const jobs = scriptPlanJobs(plan);
if (!jobs.length) return null;
const grouped = new Map<string, typeof jobs>();
for (const job of jobs) {
const key = JSON.stringify([job.scriptHash, job.interpreter, job.identity, job.windowsProfile, job.privilegedProfile,
job.arguments, job.expectedStdout, job.notBefore, job.startBefore, job.runtimeSeconds, job.outputBytes]);
const group = grouped.get(key);
if (group) group.push(job); else grouped.set(key,[job]);
}
const names = targets(plan);
return <article aria-label="Skriptinhalt"><h3>Skriptinhalt</h3>
{[...grouped.values()].map(group => {
const job = group[0]!;
return <article key={job.jobId}>
{grouped.size > 1 && <h4>{group.map(j => {
const target = names.find(t => t.asset_id === j.assetId && t.agent_id === j.agentId);
return target ? deviceName(target) : j.assetId;
}).join(', ')}</h4>}
<p>{job.revision ? job.revision.name+' · Version '+job.revision.version : 'Einmaliges Skript'} · {job.interpreter} · {identityName(job.identity)}</p>
{job.privilegedProfile === fullMaintenanceScriptProfile && <p className="warning">{fullMaintenanceWarning}</p>}
{job.identity === 'root' && job.privilegedProfile !== fullMaintenanceScriptProfile && <p className="warning">{rootWarning}</p>}
{job.interpreter === 'powershell' && <p>Windows PowerShell 5.1 · {job.windowsProfile === windowsPowerShellRemoteSignedProfile ? 'RemoteSigned für diesen Prozess' : 'Richtlinie des Geräts'}</p>}
<pre aria-label="Vollständiger Skripttext">{visibleControls(job.script)}</pre>
{job.arguments.length > 0 && <p>Argumente <code>{JSON.stringify(job.arguments)}</code></p>}
{job.expectedStdout !== null && <p>Erwartete Ausgabe <code>{JSON.stringify(job.expectedStdout)}</code></p>}
<details><summary>Ausführungsdetails und Prüfsummen</summary>
<p>{job.scriptBytes} Byte · SHA256 <code>{job.scriptHash}</code></p>
<p>Profil {job.privilegedProfile} · {job.identity} · Laufzeit {job.runtimeSeconds}s · Ausgabe bis {job.outputBytes} Byte</p>
{group.map(j => <div key={j.jobId}><p>Gerät <code>{j.assetId}</code> · Agent <code>{j.agentId}</code></p>
<p>Job <code>{j.jobId}</code> · Versuch <code>{j.attemptId}</code> · SHA256 <code>{j.jobHash}</code></p></div>)}
</details>
</article>;
})}
</article>;
} catch { return <aside role="alert" className="error">Die gespeicherten Skriptbytes konnten nicht verifiziert werden.</aside>; }
}
export function SystemPlanNotice({ plan }: { plan: RecordValue }) {
let jobs: RecordValue[];
try { jobs = systemPlanJobs(plan).filter(p => record(p.action).action === 'set_service_state'); }
catch { return <aside role="alert" className="error">Gespeicherte Planbytes sind nicht lesbar. Keine verlässliche SYSTEM-Plananzeige; Genehmigungsverifikation muss erfolgreich sein.</aside>; }
if (!jobs.length) return null;
return <aside className="warning" aria-label="Feste SYSTEM-Dienstaktionen"><p>{systemWarning}</p><ul>{jobs.map((payload, i) => { const action = record(payload.action); return <li key={i}>Identität: system · Asset: {String(payload.asset_id)} · Dienst: {String(action.unit)} · Zielzustand: {String(action.state)}</li>; })}</ul><p>Diese Definitionen stammen aus den gespeicherten Planbytes; die vollständigen Zielpayloads und Hashes stehen darunter.</p></aside>;
}
export function WindowsRebootPlanNotice({ plan }: { plan: RecordValue }) {
try {
const jobs = systemPlanJobs(plan).filter(p => record(p.action).action === 'reboot');
if (!jobs.length) return null;
return <aside className="warning" aria-label="Feste Windows-SYSTEM-Neustarts"><h3>Geplanter Windows-Neustart als SYSTEM</h3>
<p>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.</p>
<ul>{jobs.map((p, i) => <li key={i}>Asset: {String(p.asset_id)} · Job: {String(p.job_id)} · Versuch: {String(p.attempt_id)} · Grund: {String(record(p.action).reason)}</li>)}</ul>
</aside>;
} catch { return <aside role="alert" className="error">Windows-Neustartplan ist nicht aus unveränderten gespeicherten Bytes verifiziert.</aside>; }
}
export function WindowsMsiPlanNotice({ plan }: { plan: RecordValue }) {
try {
const jobs = windowsMsiPlanJobs(plan); if (!jobs.length) return null;
return <aside className="warning" aria-label="Feste SYSTEM-MSI-Paketaktionen"><p>{systemWarning}</p><p>Windows · SYSTEM · Machine · x64 · feste MSI-Profile, keine freie Installer-URL/Argumente. Diese Definition stammt ausschließlich aus hashgeprüften gespeicherten Planbytes.</p><ul>{jobs.map((job, i) => <li key={i}>
Asset: {job.assetId} · Rezept: {job.recipeId} · Rezept-SHA256: {job.recipeHash}<br/>
Artefakt: {job.artifactId} · SHA256: {job.artifactHash} · {job.artifactBytes} Bytes<br/>
ProductCode: {job.productCode} · UpgradeCode: {job.upgradeCode} · Version: {job.version} · PackageCode: {job.packageCode ?? 'im historischen1.0-Rezept nicht separat gebunden; vollständiger Artefakthash bleibt fest'}<br/>
Nutzdatei: {job.payloadPath} · SHA256: {job.payloadHash} · {job.payloadBytes} Bytes<br/>
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'}<br/>
Fester Aufruf: %SystemRoot%\System32\msiexec.exe {job.arguments.map(arg => JSON.stringify(arg)).join(' ')}<br/>
No-Reboot: true · ursprüngliches Gesamtbudget: {job.runtimeSeconds}s · Ausgabelimit: {job.outputBytes} Bytes
</li>)}</ul><p>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.</p></aside>;
} catch { return <aside role="alert" className="error">MSI-Plan ist nicht verifiziert oder wurde verändert. Keine Genehmigung ohne unveränderte gespeicherte Planbytes.</aside>; }
}
export function PowerShellPlanNotice({ plan }: { plan: RecordValue }) {
try {
const jobs = powerShellPlanJobs(plan);
if (!jobs.length) return null;
return <aside className="warning" aria-label="Feste PowerShell-Prozessprofile"><p>Diese Ausführungsoptionen sind an die hashgeprüften gespeicherten Planbytes gebunden.</p><ul>{jobs.map((job, i) => <li key={i}>Asset: {job.assetId} · Windows PowerShell5.1 · {job.identity ?? 'agent_service'} · {job.profile === windowsPowerShellRemoteSignedProfile ? 'RemoteSigned · nur Jobprozess' : 'Geerbte Richtlinie · kein ExecutionPolicy-Prozessparameter'}</li>)}</ul><p>Keine Maschinen-/CurrentUser-/GPO-Änderung durch den Executor. GPO-Vorgaben bleiben wirksam; die angeforderte Option ist kein Nachweis der effektiven Policy.</p></aside>;
} catch { return <aside role="alert" className="error">PowerShell-Planprofil ist nicht verifiziert oder wurde verändert. Keine Genehmigung ohne gültige gespeicherte Planbytes.</aside>; }
}
export function QueryLogsPlanNotice({ plan }: { plan: RecordValue }) {
try {
const jobs = queryLogsPlanJobs(plan);
if (!jobs.length) return null;
return <aside className="warning" aria-label="Feste Live-Logfenster"><p>UI-genehmigte Liveabfrage aus hashgeprüften gespeicherten Planbytes; kein passives Inventar, keine automatische Erhebung.</p><ul>{jobs.map((job, i) => <li key={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'}</li>)}</ul><p>Grenzen, Abbruch, fehlende Rechte und Teilabdeckung bleiben sichtbar. Keine Bookmarkfortschreibung durch diesen Auftrag; die Abfrage behauptet keine vollständige Sammlung aller Systemlogs.</p></aside>;
} catch { return <aside role="alert" className="error">Logfenster ist nicht verifiziert oder wurde verändert. Keine Genehmigung ohne gültige gespeicherte Planbytes.</aside>; }
}
const initialParameters: Record<Action, RecordValue> = {
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 choices = availableActions(auth, actions).filter(action => auth.principal.simulated || !['run_script', 'reboot'].includes(action));
const [scriptPlatform, setScriptPlatform] = useState('linux'), [mixedVariants, setMixedVariants] = useState('[]');
const initialAction = auth.principal.simulated ? 'run_script' : 'refresh_inventory';
const [action, setAction] = useState<Action>(initialAction), [parameters, setParameters] = useState(pretty(initialParameters[initialAction])), [error, setError] = useState<string | null>(null), [busy, setBusy] = useState(false);
const [identity, setIdentity] = useState('agent_service');
return <section><h2>Neuen unveränderlichen Plan vorbereiten</h2><p>Nur fest ausgewählte Asset-IDs. Keine Ausführung durch Planung oder Antrag; jede Aktion einschließlich Live-Inventar benötigt Genehmigung.</p>
<form onSubmit={async e => { e.preventDefault(); setBusy(true); setError(null); const f = new FormData(e.currentTarget); try {
const common = { execution_identity: String(f.get('identity')), timeout_seconds: Number(f.get('timeout')), max_output_bytes: Number(f.get('output')), ...(action === 'run_script' && f.get('privileged_script_profile') === fullMaintenanceScriptProfile ? { privileged_script_profile: fullMaintenanceScriptProfile } : {}) };
const params = action === 'run_script' ? { ...common, variants: scriptPlatform === 'mixed' ? parseStrictJson(mixedVariants) : [{ os_family: scriptPlatform, interpreter: String(f.get('interpreter')), encoding: 'utf-8', script_utf8: String(f.get('script')), ...(scriptPlatform === 'windows' ? { windows_execution_profile: windowsPowerShellRemoteSignedProfile } : {}) }], arguments: [], expected_stdout: expectedStdout(String(f.get('expected')), String(f.get('expected_format'))) } : { ...record(parseStrictJson(parameters)), ...common };
const input: PlanInput = { tenant_id: tenantId, action, targets: { asset_ids: [...selected] }, parameters: params, schedule: { not_before: new Date(String(f.get('not_before'))).toISOString(), start_before: new Date(String(f.get('expires'))).toISOString(), offline_policy: 'wait_until_deadline' }, rollout: { max_parallel: Number(f.get('parallel')), halt_after_failures: Number(f.get('failures')) }, reason: String(f.get('reason')) };
const ids = String(f.get('artifact_ids') ?? '').split(/[\s,]+/).filter(Boolean); if (ids.length) { if (ids.length > 16 || new Set(ids).size !== ids.length || ids.some(id => !/^[0-9a-f-]{36}$/i.test(id))) throw new Error('Maximal 16 eindeutige feste Artefakt-UUIDs'); input.artifact_ids = ids; }
validateInput(input); await validateSensitiveInput(input, auth); const plan = record(await request(tenantPath(tenantId, '/operation-plans'), { body: input, csrf: auth.csrf_token })); showPlan(objectId(plan, 'plan'));
} catch (e) { setError(errorText(e)); } finally { setBusy(false); } }}>
<label>Aktion<select aria-label="Aktion" value={action} onChange={e => { const next = choices.find(a => a === e.target.value); if (next) { setAction(next); setParameters(pretty(initialParameters[next])); } }}>{choices.map(a => <option key={a} value={a}>{auth.principal.simulated ? a : actionTitle(a)}</option>)}</select></label>
{action === 'update_agent' && <p className="warning">{agentUpdateWarning} Nur parameters.release_id aus dem Katalog; keine freien Vorgänger-, Dateipfad-, Artefakt- oder Policywerte. Gesamtbudget600s, Ausgabelimit höchstens65536Bytes. Fehlende frische Gerätepreview ergibt keine Planung.</p>}
{action === 'query_logs' && <p>Windows-MVP nur Quelle windows.eventlog.application.rustdiscovery-mvp-test, Kanal Application, Provider RustDiscovery-MVP-Test, agent_service. Festes UTC-Fenster höchstens24h,1–1000Events,1024–65536Bytes,äußere Joblaufzeit10–120s; inneres kooperatives Abfragebudget höchstens5000ms. Keine freie Kanal-/XPathauswahl und keine Bookmarkfortschreibung. Linux behält seine feste Journalunit.</p>}
{action === 'apt_native_acceptance' && <p className="warning">NUR SIMULIERTE DEV/TEST-NATIVABNAHME. In Vorbereitung; Backend/Helper/Scope müssen diese eigene Aktion unterstützen. Nur rmm-apt-fixture-install-1.0 oder rmm-apt-fixture-update-1.1, Rezeptversion 1, vollständiges Schema-2-Manifest. null/Platzhalter sind nicht konfiguriert, keine Produktionsaktion, keine automatische Ausführung.</p>}
{action === 'run_script' ? <><label>Skriptplattform<select aria-label="Skriptplattform" value={scriptPlatform} onChange={e => setScriptPlatform(e.target.value)}><option value="linux">Linux</option><option value="windows">Windows</option><option value="mixed">Linux und Windows · feste Varianten</option></select></label>{scriptPlatform === 'mixed' ? <label>Exakte Plattformvarianten (JSON)<textarea aria-label="Skriptvarianten" value={mixedVariants} onChange={e => setMixedVariants(e.target.value)} rows={9} spellCheck={false}/></label> : <><label>Interpreter<select name="interpreter" key={scriptPlatform}>{scriptPlatform === 'windows' ? <option value="powershell">powershell · Windows PowerShell 5.1</option> : <><option value="posix_sh">posix_sh · /bin/sh</option><option value="bash">bash · nur mit gemeldeter Capability</option></>}</select></label><label>Exakte UTF-8 Skriptbytes (keine automatische Ergänzung)<textarea name="script" required rows={7} spellCheck={false}/></label></>}<label>Format der stdout-Nachbedingung<select name="expected_format" aria-label="Format der stdout-Nachbedingung"><option value="text">Text · Linux-Default</option><option value="json">JSON-String · explizite CRLF mit \r\n</option></select></label><label>Erwartete stdout-Ausgabe (exakte Rohbytes als UTF-8, optional)<textarea name="expected" rows={2} spellCheck={false}/></label>{scriptPlatform !== 'linux' && <p>PowerShell5.1: -NoLogo -NoProfile -NonInteractive. Einzelne neue Windowspläne binden fest RemoteSigned nur für den Jobprozess. Bei gemischten Varianten ist powershell_51_remote_signed ausdrücklich an der Windowsvariante zu setzen; fehlendes Profil bleibt geerbt. Jede tatsächliche Prozessoption steht vor Genehmigung je Ziel im festen Plan. Nicht-ASCII benötigt ein ausdrücklich enthaltenes UTF-8-BOM vor Hashbildung. Skriptbytes und Ausgabe werden nicht normalisiert. Fehlende Plattform-/Interpreter-/Sync-Capability sperrt den ganzen Plan; kein stiller Zielausschluss.</p>}</> : <label>Typisierte Aktionsparameter (JSON; leere Pflichtwerte ergänzen)<textarea aria-label="Aktionsparameter" value={parameters} onChange={e => setParameters(e.target.value)} rows={9} spellCheck={false}/></label>}
<div className="grid"><label>Ausführungsidentität<select aria-label="Ausführungsidentität" name="identity" value={identity} onChange={e => setIdentity(e.target.value)}><option value="agent_service">agent_service</option><option value="root" disabled={!allowed(auth, 'root:execute')}>root · root:execute und unabhängiger Helper erforderlich</option><option value="system" disabled={!['set_service_state', 'ensure_package', 'run_script', 'update_agent'].includes(action) || !allowed(auth, 'system:execute')}>system · system:execute und Windows-SYSTEM-Helper erforderlich</option></select></label><label>Laufzeitlimit (s)<input name="timeout" key={action} type="number" min="1" max="86400" defaultValue={action === 'update_agent' ? '600' : '60'} required/></label><label>Ausgabelimit (Bytes)<input name="output" type="number" min="1" max="524288" defaultValue="65536" required/></label><label>Frühester Start (lokale Zeit)<input name="not_before" type="datetime-local" defaultValue={localDate(new Date())} required/></label><label>Startfrist / Ablauf (lokale Zeit)<input name="expires" type="datetime-local" defaultValue={localDate(new Date(Date.now() + 86400000))} required/></label><label>Maximal parallel<input name="parallel" type="number" min="1" defaultValue="1" required/></label><label>Stopp nach Fehlern<input name="failures" type="number" min="1" defaultValue="1" required/></label></div>
{action === 'run_script' && <><label>Privilegiertes Skriptprofil<select name="privileged_script_profile" aria-label="Privilegiertes Skriptprofil" key={identity} defaultValue=""><option value="">Bestehendes begrenztes Profil · keine volle Hostwartung</option><option value={fullMaintenanceScriptProfile} disabled={!['root', 'system'].includes(identity) || !allowed(auth, 'scripts:execute')}>full_maintenance_v1 · volle Hostautorität als root/SYSTEM</option></select></label><p className="warning">{fullMaintenanceWarning}</p><p>Die Auswahl erteilt keine Rechte und aktiviert keinen Client. Zentrale und lokale Policy, tatsächliche Zielcapabilities und die spätere Genehmigung werden unabhängig geprüft. SYSTEM erfordert dieses Profil; es gibt keinen automatischen Fallback.</p></>}
{identity === 'root' && !['run_script', 'update_agent'].includes(action) && <p className="warning">{rootWarning}</p>}
{identity === 'system' && !['run_script', 'update_agent'].includes(action) && <p className="warning">{systemWarning}</p>}
{identity === 'system' && action === 'ensure_package' && <p>MSI: provider=msi, package=rmm-windows-msi-fixture, architecture=x64, installation_context=machine, recipe_version=1 und vollständiges windows_msi_manifest aus dem getrennten MSI-Katalog. Genau zwei eigene Rezepte1.0/1.0→1.1;10–120s,1024–65536Bytes. APT-Manifest fehlt/null. Rezept-/Artefakthash und feste Nachbedingungen werden geprüft. Kein zusätzlicher Artefaktvektor.</p>}
{['ensure_package', 'apply_updates', 'apt_native_acceptance'].includes(action) && <details open><summary>Unveränderte Parameter-/Manifestpreview: gesamte Closure, alte/neue Versionen, Origins, Archivbytes/Hashes und Bindungen</summary><pre>{parameters}</pre><p>Struktur, exakte Transaktionsbytes und Hash werden vor Planung geprüft. Diese Vorschau behauptet keine native Akzeptanz oder Bereitschaft; keine automatische Ergänzung/Reduzierung der Closure.</p></details>}
<label>Feste importierte Artefakt-IDs (optional, maximal 16)<input name="artifact_ids" disabled={action === 'update_agent' || (identity === 'system' && action === 'ensure_package')} placeholder="MSI leitet genau eine Referenz aus dem Rezept ab; sonst UUIDs, keine URL"/></label>
<label>Begründung<input name="reason" required maxLength={1024}/></label><p>Feste Ziele ({selected.length}): {selected.join(', ') || 'keine ausgewählt'}</p>{action === 'reboot' || action === 'apply_updates' || action === 'ensure_package' ? <p className="warning">Zieländerung: Testumfang separat abstimmen. Keine implizite Reboot-/Updateerlaubnis. Neue Versuche und Folgejobs benötigen neue feste Pläne.</p> : null}<button disabled={busy || !selected.length}>Plan erstellen · noch keine Ausführung</button><ErrorBox error={error}/>
</form></section>;
}
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<string | null>(null), [revision, setRevision] = useState(0), [error, setError] = useState<string | null>(null), [busy, setBusy] = useState(false), [receipt, setReceipt] = useState<unknown>(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 <section><h2>Getrennter unveränderlicher Windows-MSI-Katalog</h2><p>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.</p><ErrorBox error={list.error}/>
{list.data && <>
{list.data.items.length ? <JsonView value={list.data.items} label="Hashgeprüfte feste MSI-Manifeste"/>
: <p>Für diesen Kunden sind keine Windows-MSI-Rezepte hinterlegt.</p>}
{(cursor || list.data.next_cursor) && <div className="list-footer">
<button disabled={!cursor} onClick={() => setCursor(null)}>Erste MSI-Rezeptseite</button>
<button disabled={!list.data.next_cursor} onClick={() => setCursor(list.data?.next_cursor ?? null)}>Nächste MSI-Rezeptseite</button>
</div>}
</>}
<details><summary>Neues festes MSI-Manifest importieren</summary><form onSubmit={async event => { 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); } }}><label>Vollständiges MSI-Manifest JSON<textarea rows={10} value={source} onChange={e => setSource(e.target.value)} spellCheck={false}/></label><button disabled={busy || !allowed(auth, 'catalog:write')}>Festes MSI-Manifest importieren · keine Ausführung</button><ErrorBox error={error}/>{receipt !== null && <JsonView value={receipt} label="Verifizierter MSI-Importbeleg"/>}</form></details>
</section>;
}
function AgentReleaseCatalog({ tenantId, auth }: { tenantId: string; auth: Session }) {
const [cursor, setCursor] = useState<string | null>(null), [revision, setRevision] = useState(0), [source, setSource] = useState('{}'), [busy, setBusy] = useState(false), [error, setError] = useState<string | null>(null), [receipts, setReceipts] = useState<unknown[]>([]);
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 <section><h2>Signierter Agent-Releasekatalog</h2><p>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.</p><ErrorBox error={list.error}/>
{!list.data && !list.error && <p>Releases werden geladen …</p>}
{list.data && !list.error && <>
{list.data.items.length ? <div className="table fleet-table release-table"><table>
<thead><tr><th scope="col">Version</th><th scope="col">Plattform</th><th scope="col">Sequenz</th><th scope="col">Prüfstatus</th></tr></thead>
<tbody>{list.data.items.map(item => {
const manifest = record(item.manifest);
const platform = stringField(manifest, 'platform');
return <tr key={objectId(item, 'release')}>
<td className="hostname"><strong>{stringField(manifest, 'version')}</strong></td>
<td data-label="Plattform">{platform.includes('windows') ? 'Windows' : 'Linux'}<small>{platform}</small></td>
<td data-label="Sequenz">{String(manifest.release_sequence)}</td>
<td data-label="Prüfstatus">{item.signature_and_time_valid ? 'Signatur und Zeitfenster gültig' : 'Derzeit ungültig'}</td>
</tr>;
})}</tbody>
</table></div> : <p>Für diesen Kunden liegen noch keine Agent-Releases im Katalog.</p>}
{(cursor || list.data.next_cursor) && <div className="list-footer">
<button className="quiet" disabled={!cursor} onClick={() => setCursor(null)}>Erste Releaseseite</button>
<button className="quiet" disabled={!list.data.next_cursor} onClick={() => setCursor(list.data?.next_cursor ?? null)}>Nächste Releaseseite</button>
</div>}
{!!list.data.items.length && <JsonView value={list.data.items} label="Manifeste und Prüfsummen"/>}
</>}
<details><summary>Signiertes festes Release mit Agent und Helper veröffentlichen</summary><p>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.</p>
<form onSubmit={async event => { 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); } }}>
<label>Vollständiger signierter Release-Envelope JSON<textarea rows={8} value={source} onChange={e => setSource(e.target.value)} spellCheck={false}/></label>
<label>Exakte Agentdatei<input type="file" name="agent_file" required/></label><label>Exakte Helperdatei<input type="file" name="helper_file" required/></label>
<button disabled={busy || !allowed(auth, 'catalog:write')}>Release für Clients veröffentlichen</button><ErrorBox error={error}/>{receipts.length > 0 && <JsonView value={receipts} label="Tatsächliche Teilimport- und Veröffentlichungsbelege"/>}
</form>
</details>
</section>;
}
function DeviceEnrollment({ tenantId, auth, customerName }: { tenantId: string; auth: Session; customerName: string }) {
const [enrollment, setEnrollment] = useState<{ token: string; expires: string; origin: string | null; platforms: string[] } | null>(null);
const [enrollmentError, setEnrollmentError] = useState<string | null>(null);
const [issuing, setIssuing] = useState(false);
const [copied, setCopied] = useState(false);
return <section aria-label="Gerät aufnehmen"><h2>Gerät aufnehmen</h2>
<p>Kunde <strong>{customerName}</strong> · Der Einmalcode gilt 15 Minuten.</p>
<h3>Installation auf dem Zielgerät</h3>
<ul>
<li><strong>Linux</strong> · Installationsskript per HTTPS laden und mit Administratorrechten starten.</li>
<li><strong>Windows</strong> · Installationsskript per HTTPS laden und in einer administrativen PowerShell starten.</li>
</ul>
<p>Die passenden Befehle erscheinen mit dem Einmalcode. Das Skript fragt den Code auf dem Zielgerät ab.</p>
<button disabled={issuing || !allowed(auth, 'devices:enroll')} onClick={async () => {
setIssuing(true); setEnrollment(null); setEnrollmentError(null); setCopied(false);
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</button>
<ErrorBox error={enrollmentError}/>
{enrollment && <><label>Einmalcode gültig bis {when(enrollment.expires)}<input readOnly value={enrollment.token}/></label>
<button onClick={async () => {
try { await navigator.clipboard.writeText(enrollment.token); setCopied(true); }
catch { setEnrollmentError('Der Browser konnte den Einmalcode nicht kopieren. Sie können ihn im Feld markieren.'); }
}}>Einmalcode kopieren</button>
<button className="quiet" onClick={() => { setEnrollment(null); setCopied(false); }}>Code ausblenden</button>
{copied && <p role="status">Einmalcode wurde kopiert.</p>}
{enrollment.origin && enrollment.platforms.includes('x86_64-unknown-linux-gnu') && <><p>Linux, mit einem Administratorkonto ausführen</p><pre>{`curl --fail --show-error --silent '${enrollment.origin}/install/linux.sh' -o linux.sh && sudo sh linux.sh '${enrollment.origin}'`}</pre></>}
{enrollment.origin && ['x86_64-pc-windows-gnu','x86_64-pc-windows-msvc'].filter(p => enrollment.platforms.includes(p)).map(platform =>
<div key={platform}><p>Windows {platform.endsWith('-gnu') ? 'x64 (GNU)' : 'x64 (MSVC)'}, in einer administrativen Windows PowerShell ausführen</p>
<pre>{`Invoke-WebRequest -UseBasicParsing '${enrollment.origin}/install/windows.ps1' -OutFile .\\windows.ps1
.\\windows.ps1 -BootstrapBase '${enrollment.origin}' -Platform '${platform}'`}</pre></div>)}
</>}
</section>;
}
async function verifyReview(plan: RecordValue, tenantId: string, id: string) {
await verifyPlanIntegrity(plan);
await verifyScriptPlan(plan);
await verifyAgentUpdatePlan(plan);
const saved = record(plan.plan_payload);
if (plan.plan_id !== id || saved.plan_id !== id || saved.tenant_id !== tenantId || !Array.isArray(plan.plan_payload_bytes)) {
throw new Error('Der gespeicherte Plan gehört nicht zu diesem Auftrag und Kunden.');
}
}
function reviewBlockers(plan: RecordValue) {
return [
...approvalBlockers(plan), ...powerShellApprovalBlockers(plan), ...queryLogsApprovalBlockers(plan),
...windowsMsiApprovalBlockers(plan), ...scriptApprovalBlockers(plan), ...agentUpdateApprovalBlockers(plan)
];
}
function PlanDetail({ tenantId, id, auth, onOperation, customerName, mode = 'review' }: {
tenantId: string; id: string; auth: Session; onOperation: (id: string) => void;
customerName?: string; mode?: 'review' | 'submit';
}) {
const path = tenantPath(tenantId, '/operation-plans/' + encodeURIComponent(id));
const plan = useResource(async signal => {
const value = record(await request(path, { signal }));
await verifyReview(value, tenantId, id);
return value;
}, [tenantId, id], mode === 'review');
const [error, setError] = useState<string | null>(null);
const [busy, setBusy] = useState(false);
const [confirmedHash, setConfirmedHash] = useState('');
const data = plan.error ? null : plan.data;
if (!data) return <section data-plan-id={id}><ErrorBox error={plan.error ?? error}/>{!plan.error && <p>Plan wird geprüft …</p>}</section>;
const saved = record(data.plan_payload);
const payloads = (saved.jobs as unknown[]).map(job => record(record(job).payload));
const first = payloads[0];
const revision = saved.script_revision ? record(saved.script_revision) : null;
const title = revision ? display(revision.name) : actionTitle(first && record(first.action).action);
const script = first && record(first.action).action === 'run_script';
const blockers = reviewBlockers(data);
const pending = data.approval_state === 'pending_approval';
const planHash = stringField(data,'plan_hash');
const confirmed = confirmedHash === planHash;
const mayDecide = mode === 'review' && pending && !!auth.csrf_token && allowed(auth, 'plans:approve');
const rights = new Set<string>();
payloads.forEach(p => {
const action = record(p.action).action;
if (action === 'run_script') rights.add('scripts:execute');
if (action === 'update_agent') rights.add('updates:apply');
if (p.execution_identity === 'system' || p.execution_identity === 'root') rights.add(p.execution_identity + ':execute');
});
const missingRights = [...rights].filter(permission => !allowed(auth, permission));
async function act(decision: 'submit'|'approve'|'reject') {
if (busy || !data || plan.error) return;
setBusy(true); setError(null);
try {
await verifyReview(data, tenantId, id);
if (decision !== 'reject') {
const problems = reviewBlockers(data);
if (problems.length) throw new Error(problems.join(' · '));
}
if (decision === 'submit' && (mode !== 'submit' || !allowed(auth,'operations:submit'))) throw new Error('Einreichung nicht erlaubt.');
if (decision !== 'submit' && (!mayDecide || !confirmed)) throw new Error('Prüfung und Berechtigung erforderlich.');
if (decision === 'approve' && missingRights.length) throw new Error('Erforderliche Ausführungsrechte fehlen.');
const submit = decision === 'submit';
const result = record(await request(path + (submit ? '/submit' : '/authorizations'), {
csrf: auth.csrf_token, body: submit ? { idempotency_key: 'web-plan-' + id } : { plan_hash: planHash, decision }
}));
setConfirmedHash('');
onOperation(objectId(result, 'operation'));
plan.reload();
} catch (e) {
setError(errorText(e)); setConfirmedHash(''); plan.reload();
} finally { setBusy(false); }
}
const names = targets(data);
const duplicateNames = new Set(names.filter((t,i) => t.hostname && names.some((other,j) => j !== i && other.hostname === t.hostname)).map(t => t.hostname));
const displayTarget = (p: RecordValue) => {
const target = names.find(t => t.asset_id === p.asset_id && t.agent_id === p.agent_id);
if (!target?.hostname) return display(p.asset_id);
return display(target.hostname) + (duplicateNames.has(target.hostname) ? ' (' + String(p.asset_id) + ')' : '');
};
return <section data-plan-id={id} className="request-review">
<h2>{title}{revision ? ' · Version '+String(revision.version) : ''}</h2>
<dl className="facts">
<Fact label="Kunde">{display(customerName, display(data.customer_name, tenantId))}</Fact>
<Fact label="Antragsteller"><Requester id={data.requester ?? saved.principal} ownId={auth.principal.id}/></Fact>
{typeof data.requester === 'string' && data.requester !== saved.principal && <Fact label="Plan erstellt von">
<Requester id={saved.principal} ownId={auth.principal.id}/>
</Fact>}
<Fact label="Status">{data.approval_state ? <Status value={data.approval_state}/> : 'Vorbereitet'}</Fact>
{typeof data.approval_state === 'string' && data.approval_state !== 'pending_approval' && <Fact label="Entscheidung">
<ApprovalDecision order={data} ownId={auth.principal.id}/>
</Fact>}
<Fact label="Anlass">{display(saved.reason, 'Kein Anlass angegeben')}</Fact>
</dl>
<h3>Zielgeräte und Zeitfenster</h3>
<ul className="review-targets">{payloads.map(p => <li key={String(p.job_id)}>
<strong>{displayTarget(p)}</strong> · {identityName(p.execution_identity)}
<small>{when(p.not_before)} bis {when(p.start_before)} · Laufzeit bis {String(p.max_runtime_seconds)} s</small>
</li>)}</ul>
<p>Höchstens {String(saved.max_parallel)} gleichzeitig · Stopp nach {String(saved.halt_after_failures)} {saved.halt_after_failures === 1 ? 'Fehler' : 'Fehlern'}</p>
<AgentUpdatePlanNotice plan={data}/><ScriptPlanNotice plan={data}/>
<SystemPlanNotice plan={data}/><WindowsRebootPlanNotice plan={data}/><WindowsMsiPlanNotice plan={data}/>
{!script && <PowerShellPlanNotice plan={data}/>}<QueryLogsPlanNotice plan={data}/>
{!script && <details><summary>Aktionen je Gerät</summary>{payloads.map(p => <article key={String(p.job_id)}>
<strong>{displayTarget(p)}</strong><pre>{pretty(p.action)}</pre>
</article>)}</details>}
<JsonView value={data} label="Technische Plandaten"/>
<ErrorBox error={error ?? plan.error}/>
{(pending || mode === 'submit') && blockers.length > 0 && <p role="alert" className="error">{blockers.join(' · ')}</p>}
{mode === 'submit' && !data.approval_state && allowed(auth, 'operations:submit') &&
<button className="primary" disabled={busy || !!plan.error || !!blockers.length} onClick={() => void act('submit')}>Zur Genehmigung einreichen</button>}
{mode === 'submit' && typeof data.operation_id === 'string' && <button className="quiet" onClick={() => onOperation(objectId(data, 'operation'))}>Eingereichten Auftrag öffnen</button>}
{mayDecide && <fieldset disabled={busy || !!plan.error}><legend>Entscheidung</legend>
{!!missingRights.length && <p className="warning">Für die Genehmigung fehlen Rechte: {missingRights.join(', ')}.</p>}
<label className="check"><input type="checkbox" checked={confirmed} onChange={e => setConfirmedHash(e.target.checked ? planHash : '')}/>
Ich habe die Geräte, den Inhalt und die Ausführungsrechte geprüft.</label>
<button className="primary" disabled={!confirmed || !!blockers.length || !!missingRights.length} onClick={() => void act('approve')}>
{auth.principal.simulated ? 'SIMULIERT: Genehmigen' : 'Genehmigen'}
</button>{' '}
<button disabled={!confirmed} onClick={() => void act('reject')}>{auth.principal.simulated ? 'SIMULIERT: Ablehnen' : 'Ablehnen'}</button>
</fieldset>}
{mode === 'review' && data.approval_state === 'approved' && allowed(auth,'plans:revoke') && <details><summary>Berechtigung verwalten</summary>
<AdminControl auth={auth} path={path + '/revocation'} permission="plans:revoke" title="Planberechtigung widerrufen"
warning="Ein Widerruf sperrt neue Starts dieses Plans." done={plan.reload}/>
</details>}
</section>;
}
const emptyOrderFilters = { q: '', device: '', status: '', from: '', to: '' };
type OrderFilters = typeof emptyOrderFilters;
const orderStatuses = ['pending_approval', 'approved', 'queued', 'running', 'succeeded', 'partially_succeeded',
'failed', 'needs_attention', 'rejected', 'expired', 'revoked', 'cancelled'];
function orderDay(value: string, next = false) {
const date = new Date(value + 'T00:00:00');
if (next) date.setDate(date.getDate() + 1);
return date.toISOString();
}
function Operations({ tenantId, open, customerName, filters, apply }: {
tenantId: string; open: (id: string) => void; customerName?: string;
filters: OrderFilters; apply: (filters: OrderFilters) => void;
}) {
const [pages, setPages] = useState<string[]>([]);
const [draft, setDraft] = useState(filters);
const [filterError, setFilterError] = useState<string | null>(null);
const cursor = pages[pages.length - 1];
const params = new URLSearchParams({sort:'recent', limit:'25'});
if (cursor) params.set('cursor', cursor);
if (filters.q) params.set('q', filters.q);
if (filters.device) params.set('device', filters.device);
if (filters.status) params.set('status', filters.status);
if (filters.from) params.set('from', orderDay(filters.from));
if (filters.to) params.set('until', orderDay(filters.to, true));
const query = params.toString();
const list = useResource(async signal => page(await request(tenantPath(tenantId, '/operations?' + query), { signal })), [tenantId, query], true);
const filtering = Object.values(filters).some(Boolean);
function reset() {
setDraft(emptyOrderFilters);
setFilterError(null);
setPages([]);
apply(emptyOrderFilters);
}
return <section aria-label="Auftragsliste" className="fleet">
<form className="order-filters" aria-label="Aufträge filtern" onSubmit={event => {
event.preventDefault();
if (draft.from && draft.to && draft.from > draft.to) {
setFilterError('Das Enddatum darf nicht vor dem Startdatum liegen.');
return;
}
setPages([]);
setFilterError(null);
apply({ ...draft, q: draft.q.trim(), device: draft.device.trim() });
}}>
<label>Auftrag<input type="search" maxLength={120} value={draft.q} onChange={e => setDraft({ ...draft, q:e.target.value })} placeholder="Name oder Anlass"/></label>
<label>Gerät<input type="search" maxLength={120} value={draft.device} onChange={e => setDraft({ ...draft, device:e.target.value })} placeholder="Hostname oder Geräte-ID"/></label>
<label>Status<select aria-label="Status" value={draft.status} onChange={e => setDraft({ ...draft, status:e.target.value })}>
<option value="">Alle Status</option>
{orderStatuses.map(status => <option key={status} value={status}>{statusText(status)}</option>)}
</select></label>
<label>Von<input type="date" value={draft.from} onChange={e => setDraft({ ...draft, from:e.target.value })}/></label>
<label>Bis einschließlich<input type="date" value={draft.to} onChange={e => setDraft({ ...draft, to:e.target.value })}/></label>
<div className="order-filter-actions">
<button type="submit">Filtern</button>
{(filtering || Object.values(draft).some(Boolean)) && <button type="button" className="quiet" onClick={reset}>Filter zurücksetzen</button>}
</div>
<ErrorBox error={filterError}/>
</form>
<ErrorBox error={list.error}/>
{!list.data && !list.error && <p className="list-message">Aufträge werden geladen …</p>}
{list.data && !list.error && (list.data.items.length
? <OrderRows items={list.data.items} customerName={customerName} open={row => open(objectId(row,'operation'))}/>
: <p className="list-message">{filtering ? 'Keine Aufträge passen zu den Filtern.' : 'Für diesen Kunden gibt es noch keine Aufträge.'}</p>)}
{list.data && !list.error && <PageButtons pages={pages} next={list.data.next_cursor} change={setPages}/>}
</section>;
}
function OrderScript({ tenantId, operation, names }: { tenantId: string; operation: RecordValue; names: RecordValue[] }) {
const operationId = objectId(operation, 'operation');
const planId = objectId(operation, 'plan');
const planHash = stringField(operation, 'plan_hash');
const scripts = useResource(async signal => {
const plan = record(await request(tenantPath(tenantId, '/operation-plans/' + encodeURIComponent(planId)), { signal }));
const stored = record(plan.plan_payload);
if (plan.operation_id !== operationId || plan.plan_hash !== planHash ||
plan.plan_id !== planId || stored.plan_id !== planId || stored.tenant_id !== tenantId) {
throw new Error('Der Skriptinhalt konnte diesem Auftrag nicht zugeordnet werden.');
}
await verifyScriptPlan(plan);
const jobs = scriptPlanJobs(plan);
if (!jobs.length) throw new Error('Für diesen Auftrag ist kein Skriptinhalt gespeichert.');
const variants = new Map<string, typeof jobs>();
for (const job of jobs) {
const key = JSON.stringify([job.scriptHash, job.interpreter]);
const group = variants.get(key);
if (group) group.push(job);
else variants.set(key, [job]);
}
return [...variants.values()];
}, [tenantId, operationId, planId, planHash]);
const variants = scripts.error ? [] : scripts.data ?? [];
return <article className="order-script" aria-label="Skriptinhalt">
<h3>Skriptinhalt</h3>
<ErrorBox error={scripts.error}/>
{!scripts.data && !scripts.error && <p>Skriptinhalt wird geladen …</p>}
{variants.map(group => {
const script = group[0]!;
return <div key={script.scriptHash + '/' + script.interpreter}>
{variants.length > 1 && <h4>{group.map(job => {
const target = names.find(item => item.asset_id === job.assetId && item.agent_id === job.agentId);
return target ? deviceName(target) : job.assetId;
}).join(', ')}</h4>}
<p className="muted">{script.revision ? 'Version ' + script.revision.version : 'Einmaliges Skript'} · {script.interpreter}</p>
<pre className="script-body" aria-label="Gespeicherter Skripttext" tabIndex={0}>{visibleControls(script.script.replace(/\r\n/g, '\n'))}</pre>
</div>;
})}
</article>;
}
function OperationDetail({ tenantId, id, resultId: linkedResult, auth, openPlan, customerName }: {
tenantId: string; id: string; resultId?: string; auth: Session; openPlan: (id: string) => void; customerName?: string
}) {
const op = useResource(async signal => record(await request(tenantPath(tenantId, '/operations/' + encodeURIComponent(id)), { signal })), [tenantId, id], true);
const [jobId, setJobId] = useState<string | null>(linkedResult ?? null);
const data = op.error ? null : op.data;
if (!data) return <section data-operation-id={id}><ErrorBox error={op.error}/>{!op.error && <p>Auftrag wird geladen …</p>}</section>;
const names = targets(data);
const jobs = Array.isArray(data.jobs) ? data.jobs.map(j => record(j)) : [];
const resultMissing = !!linkedResult && !jobs.some(job => job.job_id === linkedResult);
const singleJob = jobs.length === 1 && !resultMissing ? jobs[0] : null;
const name = (job: RecordValue) => {
const target = names.find(t => t.asset_id === job.asset_id && t.agent_id === job.agent_id);
return target ? deviceName(target) : display(job.asset_id, 'Gerät unbekannt');
};
return <section data-operation-id={id}><ErrorBox error={op.error}/><h2>{orderTitle(data)}</h2>
<dl className="facts"><Fact label="Kunde">{display(data.customer_name, customerName)}</Fact>
<Fact label="Status"><Status value={statusOf(data)}/></Fact><Fact label="Eingereicht">{when(data.created_at)}</Fact>
<Fact label="Antragsteller"><Requester id={data.requester} ownId={auth.principal.id}/></Fact>
<Fact label="Anlass">{display(data.reason, 'Kein Anlass angegeben')}</Fact></dl>
<div className="order-execution">
{singleJob ? <JobDetail key={objectId(singleJob, 'job')} tenantId={tenantId}
id={objectId(singleJob, 'job')} hostname={name(singleJob)} auth={auth} scrollToResult={!!linkedResult}/>
: <div className="order-results">
<h3>Geräte und Ergebnisse</h3>
{resultMissing && <p role="alert">Das verlinkte Geräteergebnis gehört nicht zu diesem Auftrag oder ist nicht mehr verfügbar.</p>}
{jobs.length ? <ul className="job-list">{jobs.map(job => {
const resultId = objectId(job, 'job');
const hostname = name(job);
const expanded = jobId === resultId;
const action = expanded ? 'Ergebnis schließen' : 'Ergebnis anzeigen';
return <li key={resultId}>
<div className="job-row">
<strong>{hostname}</strong>
<Status value={job.state}/>
<button type="button" data-job-id={resultId} aria-expanded={expanded}
aria-label={action + ' für ' + hostname}
onClick={() => setJobId(expanded ? null : resultId)}>{action}</button>
</div>
{expanded && <JobDetail tenantId={tenantId} id={resultId} hostname={hostname} auth={auth}
scrollToResult={!!jobId && jobId === linkedResult}/>}
</li>;
})}</ul>
: <><p>{names.map(deviceName).join(', ')}</p><p className="muted">{data.approval_state === 'pending_approval'
? 'Nach der Genehmigung erscheint hier der Fortschritt je Gerät.' : 'Für diesen Auftrag liegen keine Ausführungen vor.'}</p></>}
</div>}
{data.action === 'run_script' && <OrderScript tenantId={tenantId} operation={data} names={names}/>}
</div>
{allowed(auth, 'plans:approve') && <button className="quiet" onClick={() => openPlan(objectId(data,'plan'))}>
{data.approval_state === 'pending_approval' ? 'Antrag prüfen' : 'Genehmigungsdetail öffnen'}
</button>}
<JsonView value={data} label="Technische Auftragsdaten"/>
</section>;
}
function JobDetail({ tenantId, id, auth, hostname, scrollToResult }: {
tenantId: string; id: string; auth: Session; hostname: string; scrollToResult?: boolean
}) {
const job = useResource(async signal => record(await request(tenantPath(tenantId, '/jobs/'+encodeURIComponent(id)), { signal })), [tenantId, id], true);
const result = useRef<HTMLElement>(null);
useEffect(() => {
if (scrollToResult) result.current?.scrollIntoView({ block:'start' });
}, [id, scrollToResult]);
const [error, setError] = useState<string | null>(null), [busy, setBusy] = useState(false);
const data = job.error ? null : job.data;
const state = data?.state;
const terminal = ['succeeded','failed','cancelled','expired','unknown','closed_unknown'];
return <article ref={result} className="job-result" data-job-id={id}><h3>Ergebnis für {hostname}</h3><ErrorBox error={job.error ?? error}/>
{!data && !job.error && <p>Ergebnis wird geladen …</p>}
{data && <><ConsoleOutput job={data}/><JsonView value={data} label="Technische Ausführungsdaten"/></>}
{data && allowed(auth,'jobs:cancel') && !terminal.includes(String(state)) && !data.cancel_requested && <details><summary>Abbruch anfordern</summary>
<form onSubmit={async e => {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);}
}}><label>Abbruchgrund<input name="reason" required/></label><button disabled={busy}>Abbruch anfordern</button></form>
</details>}
{data && state === 'unknown' && <UnknownClosure tenantId={tenantId} id={id} job={data} auth={auth} done={job.reload}/>}
</article>;
}
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<string | null>(null);
const eligible = allowed(auth, 'plans:approve') && !!auth.csrf_token;
return <section aria-label="Unknown-Job abschließen"><h4>Unknown-Job abschließen</h4><ErrorBox error={error}/>
<p className="warning">Die Wirkung dieses Versuchs bleibt unbekannt. Der Abschluss wertet ihn weder als Erfolg noch als Fehlschlag oder Nichtstart, wiederholt ihn nie und erteilt keine neue Genehmigung. Er hebt nur die Sperre des Geräts für neue, eigens genehmigte Aufträge auf. Originaldaten bleiben erhalten.</p>
<label>Begründung<input value={reason} maxLength={1024} onChange={e => setReason(e.target.value)} required/></label>
<label className="check"><input type="checkbox" checked={confirmed} onChange={e => setConfirmed(e.target.checked)}/>Ich akzeptiere, dass die Wirkung dieses Versuchs unbekannt bleibt und er nicht wiederholt wird.</label>
<button className="danger" disabled={!eligible || !confirmed || busy || !reason.trim()} onClick={async () => { setBusy(true); setError(null); try {
await request(tenantPath(tenantId, `/jobs/${encodeURIComponent(id)}/unknown-closure`), { csrf: auth.csrf_token, body: { attempt_id: stringField(job, 'attempt_id'), revision: job.revision, reason: reason.trim() } }); setConfirmed(false); done();
} catch (e) { setError(errorText(e)); } finally { setBusy(false); } }}>{auth.principal.simulated ? 'SIMULIERT: Unknown-Job ausdrücklich abschließen' : 'Unknown-Job ausdrücklich abschließen'}</button></section>;
}
const pages: Record<NavKey, string> = {
geraete: 'Geräte',
auftraege: 'Aufträge',
genehmigungen: 'Genehmigungen',
skripte: 'Skripte',
kunden: 'Kunden',
verwaltung: 'Verwaltung'
};
function currentRoute() {
const [key = 'geraete', ...parts] = window.location.hash.slice(1).split('/');
return { page: (Object.hasOwn(pages, key) ? key : 'geraete') as NavKey, tab: parts.join('/') };
}
function go(page: NavKey, tab = '') {
window.location.hash = page + (tab ? '/' + tab : '');
}
function Workspace({ auth, logout }: { auth: Session; logout: () => void }) {
const [route, setRoute] = useState(currentRoute);
useEffect(() => {
const change = () => {
setRoute(currentRoute());
window.scrollTo(0, 0);
};
window.addEventListener('hashchange', change);
return () => window.removeEventListener('hashchange', change);
}, []);
useEffect(() => {
document.title = pages[route.page] + ' · Rust Discovery';
}, [route.page]);
const tenants = useResource(
async (signal) => {
const data = record(await request('/api/v1/tenants', { signal }));
return { items: page(data).items.map(tenant), canManage: data.can_manage_customers === true };
},
[auth.principal.id]
);
const customers = tenants.data?.items ?? auth.tenants;
const [selectedCustomer, setCustomer] = useState(auth.tenants[0]?.tenant_id ?? '');
const [detailKind, detailTenant, detailId, detailJob] = route.tab.split('/');
const [orderFilters, setOrderFilters] = useState(emptyOrderFilters);
const detailRoute = (route.page === 'genehmigungen' && detailKind === 'pruefen')
|| (route.page === 'auftraege' && (detailKind === 'ansehen' || detailKind === 'entwurf'));
const deviceCustomer = route.page === 'geraete' && detailKind && detailTenant && detailId ? detailKind : '';
const fixedCustomer = detailRoute ? detailTenant : deviceCustomer;
const customer = fixedCustomer || selectedCustomer;
const [inboxRevision, refreshInbox] = useState(0);
const pendingCount = usePendingApprovals(true, inboxRevision);
const [allDeviceCustomers, setAllDeviceCustomers] = useState(true);
const fleetFilter = allDeviceCustomers ? '' : selectedCustomer;
const [selection, setSelection] = useState<{ customer: string; ids: string[] }>({
customer: '',
ids: []
});
const [error, setError] = useState<string | null>(null);
useEffect(() => {
if (fixedCustomer && fixedCustomer !== selectedCustomer && customers.some(c => c.tenant_id === fixedCustomer)) {
setCustomer(fixedCustomer);
setSelection({ customer: '', ids: [] });
}
}, [customers, fixedCustomer, selectedCustomer]);
function switchCustomer(id: string) {
if (id === selectedCustomer) return;
setSelection({ customer: '', ids: [] });
setCustomer(id);
}
function selectFleetCustomer(id: string) {
setAllDeviceCustomers(!id);
setSelection({ customer: '', ids: [] });
if (id) switchCustomer(id);
}
const primaryTenant = auth.tenants[0]?.tenant_id;
const current = useResource(
async (signal) => {
if (!customer || customer === primaryTenant) return { id: customer, auth };
const scoped = session(await request('/auth/session', { signal, tenantId: customer }));
return { id: customer, auth: scoped };
},
[customer, auth]
);
// Gate rendering during a tenant change; a previously loaded session is scoped to its own customer.
const scoped = current.data?.id === customer ? current.data.auth : null;
const customerName = customers.find((c) => c.tenant_id === customer)?.name ?? '';
const canChooseCustomer = !fixedCustomer && route.page !== 'genehmigungen' && customers.length > 0;
function openOperation(tenantId: string, id: string, jobId?: string) {
switchCustomer(tenantId);
go('auftraege', orderDetailRoute(tenantId, id, jobId));
}
function openReview(tenantId: string, id: string) {
switchCustomer(tenantId);
go('genehmigungen', `pruefen/${tenantId}/${id}`);
}
function showDraft(id: string) {
go('auftraege', `entwurf/${customer}/${id}`);
}
function afterSubmission(id: string) {
refreshInbox(value => value + 1);
openOperation(customer, id);
}
const selected = selection.customer === customer ? selection.ids : [];
const tabs: [string, string][] = [
['zugang', 'MCP-Tokens'],
['aufnahme', 'Geräteaufnahme'],
['releases', 'Agent-Releases'],
['kataloge', 'Erweitert'],
['rechte', 'Rechte & Ausführungsstopp']
];
const adminTab = tabs.some(([id]) => id === route.tab) ? route.tab : 'zugang';
return (
<div className="workbench">
<aside className="sidebar">
<a className="brand" href="#geraete" aria-label="Rust Discovery – Geräte">
<span className="brand-mark" aria-hidden="true">
<i />
<i />
<i />
</span>
Rust Discovery
</a>
<nav aria-label="Hauptnavigation">
{(Object.entries(pages) as [NavKey, string][]).map(([key, title]) => (
<a key={key} href={'#' + key} aria-current={route.page === key ? 'page' : undefined}>
<NavIcon name={key} />
<span>{title}</span>
{key === 'genehmigungen' && typeof pendingCount === 'number' && pendingCount > 0 &&
<b className="nav-count" aria-label={`${pendingCount} offene Anträge`}>{pendingCount}</b>}
</a>
))}
</nav>
<div className="account">
<div>
<span className="account-dot" aria-hidden="true" />
<span title={auth.principal.id}>{auth.principal.display_name === auth.principal.id && auth.principal.id.startsWith('local:') ? 'Lokales Konto' : auth.principal.display_name}</span>
</div>
<button
onClick={async () => {
try {
await request('/auth/logout', { csrf: auth.csrf_token, body: {} });
window.history.replaceState(null, '', window.location.pathname + window.location.search);
logout();
} catch (e) {
setError(errorText(e));
}
}}
>
<NavIcon name="abmelden" /> Abmelden
</button>
</div>
</aside>
<div className="work-area">
<header className="topline">
<div className="crumb">
<span>Arbeitsbereich</span>
<i aria-hidden="true">/</i>
<b>{pages[route.page]}</b>
</div>
{canChooseCustomer ? (
<label className="context">
<span>Kunde</span>
<select aria-label="Kunde" title={customerName} value={customer} onChange={(e) => selectFleetCustomer(e.target.value)}>
{customers.map((c) => (
<option value={c.tenant_id} key={c.tenant_id}>
{c.name}
</option>
))}
</select>
</label>
) : <div className="context" aria-label={fixedCustomer ? 'Kunde der Detailansicht' : 'Aktiver Kunde'}>
<span>{fixedCustomer ? 'Kunde' : 'Aktiver Kunde'}</span>
<strong>{customerName || (tenants.data ? 'Nicht verfügbar' : 'Wird geladen …')}</strong>
</div>}
</header>
{auth.principal.simulated && (
<aside className="simulation" role="status">
SIMULIERT · dev/test-Testprincipal · Genehmigung ist eine Entwicklungs-Browsersimulation,
kein menschlicher Produktions-Freigabenachweis.
</aside>
)}
<main className="content">
<ErrorBox error={error} />
<ErrorBox error={tenants.error} />
<ErrorBox error={current.error} />
{route.page === 'geraete' && (
<Devices
detailPath={route.tab}
auth={scoped ?? { ...auth, permissions: [] }}
customers={customers}
filter={fleetFilter}
onFilter={selectFleetCustomer}
selection={selection}
onSelection={(value) => {
if (value.customer) switchCustomer(value.customer);
setSelection(value);
}}
onEnroll={() => go('verwaltung', 'aufnahme')}
onCreateOrder={() => go('auftraege', 'neu')}
onOperation={openOperation}
/>
)}
{route.page === 'kunden' && (
<>
<div className="page-title">
<h1>Kunden</h1>
</div>
<CustomerManagement
auth={auth}
customers={customers}
canManage={tenants.data?.canManage === true}
onChange={tenants.reload}
onSelect={(id) => {
selectFleetCustomer(id);
go('geraete');
}}
/>
</>
)}
{!['geraete', 'kunden'].includes(route.page) && (!customer || !scoped) && !current.error && (
<p>Kundenbereich wird geladen …</p>
)}
{scoped && (
<React.Fragment key={customer}>
{route.page === 'skripte' && <ScriptLibrary tenantId={customer} auth={scoped} />}
{route.page === 'genehmigungen' && (
detailRoute && detailId ? <>
<a href="#genehmigungen" className="back-link">← Zu den Genehmigungen</a>
<PlanDetail key={detailId} tenantId={customer} id={detailId} auth={scoped}
customerName={customerName} mode="review" onOperation={afterSubmission} />
</> : <><div className="page-title"><h1>Genehmigungen</h1></div><ApprovalInbox ownId={auth.principal.id} open={openReview} /></>
)}
{route.page === 'auftraege' && (
route.tab === 'neu' ? <>
<a href="#auftraege" className="back-link">← Zu den Aufträgen</a>
<OrderComposer tenantId={customer} customerName={customerName} auth={scoped} initialAssetIds={selected} onSubmitted={afterSubmission} onDraft={showDraft} />
</> : route.tab === 'wartung' ? <>
<a href="#verwaltung/kataloge" className="back-link">← Zur erweiterten Verwaltung</a>
<div className="page-title"><h1>Wartungsauftrag planen</h1></div>
{allowed(scoped, 'operations:plan') ? <>
<a className="quiet" href="#geraete">Geräte auswählen</a>
<Planner tenantId={customer} auth={scoped} selected={selected} showPlan={showDraft} />
</> : <p>Die Berechtigung zum Planen von Aufträgen fehlt.</p>}
</> : detailRoute && detailId ? <>
<a href="#auftraege" className="back-link">← Zu den Aufträgen</a>
{detailKind === 'entwurf' ?
<PlanDetail key={detailId} tenantId={customer} id={detailId} auth={scoped}
customerName={customerName} mode="submit" onOperation={afterSubmission} />
: <OperationDetail key={detailId+'/'+(detailJob ?? '')} tenantId={customer} id={detailId} resultId={detailJob} auth={scoped}
customerName={customerName} openPlan={id => openReview(customer,id)} />}
</> : <>
<div className="page-title"><h1>Aufträge</h1>
{allowed(scoped, 'operations:plan') && <a className="primary-action" href="#auftraege/neu"><NavIcon name="plus" /> Neuer Auftrag</a>}
</div>
<Operations tenantId={customer} customerName={customerName} open={id => openOperation(customer,id)}
filters={orderFilters} apply={setOrderFilters}/>
</>
)}
{route.page === 'verwaltung' && (
<>
<div className="page-title">
<h1>Verwaltung</h1>
</div>
<nav className="subnav" aria-label="Verwaltungsbereiche">
{tabs.map(([id, title]) => (
<a
href={'#verwaltung/' + id}
key={id}
aria-current={adminTab === id ? 'page' : undefined}
>
{title}
</a>
))}
</nav>
{adminTab === 'zugang' && <McpTokenManagement tenantId={customer} auth={scoped} />}
{adminTab === 'aufnahme' && <DeviceEnrollment tenantId={customer} auth={scoped} customerName={customerName} />}
{adminTab === 'releases' && <AgentReleaseCatalog tenantId={customer} auth={scoped} />}
{adminTab === 'kataloge' && (
<>
{allowed(scoped, 'operations:plan') && <section>
<h2>Erweiterte Wartung</h2>
<a className="quiet" href="#auftraege/wartung">Wartungsauftrag planen</a>
</section>}
<Catalog tenantId={customer} auth={scoped} />
<WindowsMsiCatalog tenantId={customer} auth={scoped} />
</>
)}
{adminTab === 'rechte' && <TenantControls tenantId={customer} auth={scoped} />}
</>
)}
</React.Fragment>
)}
</main>
</div>
</div>
);
}
function App() {
const [auth, setAuth] = useState<Session | null>(null), [loading, setLoading] = useState(true), [error, setError] = useState<string | null>(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 <main>Sitzung wird geprüft …</main>;
return <><ErrorBox error={error}/>{auth ? <><ErrorBox error={config.error}/><Workspace auth={auth} logout={() => { setAuth(null); setError(null); config.reload(); }}/></> : <Login config={config.data} configError={config.error} onLogin={s => { 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 ? <main><h1>Darstellung blockiert</h1><ErrorBox error={this.state.error}/><p>Keine verlässliche Anzeige möglich. Nach Vertragskorrektur Seite neu laden.</p></main> : this.props.children; }
}
createRoot(document.getElementById('root')!).render(<Boundary><App/></Boundary>);