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

888 lines
62 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 { ApiError, authConfig, approvalBlockers, objectId, page, pretty, record, RecordValue, request, session, Session, stringField, tenant, tenantPath, windowsPowerShellRemoteSignedProfile, fullMaintenanceScriptProfile } from './api';
import './style.css';
import { AdminControl, Catalog, TenantControls } from './management';
import { allowed, parseStrictJson, powerShellApprovalBlockers, powerShellPlanJobs, rootWarning, systemWarning, systemPlanJobs, verifyPlanIntegrity, queryLogsApprovalBlockers, queryLogsPlanJobs, windowsMsiApprovalBlockers, windowsMsiPlanJobs, verifyWindowsMsiManifest, adminScriptWarning } 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">{adminScriptWarning}</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>; }
}
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);
const [adminScripts, setAdminScripts] = useState(false);
const origin = enrollment?.origin;
const linuxArchitectures = [
['x86_64-unknown-linux-gnu', 'x86-64'],
['aarch64-unknown-linux-gnu', 'ARM64'],
] as const;
const availableLinuxArchitectures = linuxArchitectures.filter(([target]) => enrollment?.platforms.includes(target)).map(([, label]) => label);
const linuxInstaller = origin && availableLinuxArchitectures.length > 0 ? `${origin}/install/linux.sh` : null;
const windowsPlatforms = ['x86_64-pc-windows-gnu', 'x86_64-pc-windows-msvc'].filter(platform => enrollment?.platforms.includes(platform));
const windowsInstaller = origin && windowsPlatforms.length > 0 ? `${origin}/install/windows.ps1` : null;
return <section aria-label="Gerät aufnehmen"><h2>Gerät aufnehmen</h2>
<p>Wählen Sie oben den Kunden für das neue Gerät. Der Einmalcode gilt für <strong>{customerName}</strong> und verfällt nach erfolgreicher Aufnahme oder nach 15 Minuten.</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');
const bootstrap = typeof result.bootstrap_origin === 'string' ? new URL(result.bootstrap_origin) : null;
setEnrollment({ token: result.token, expires: result.expires_at, origin: bootstrap?.protocol === 'https:' ? bootstrap.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>}
</>}
<article>
<h3>Installation auf dem neuen Gerät</h3>
<ol>
<li>Öffnen Sie auf dem neuen Linux-Gerät ein Terminal mit <code>sudo</code>-Rechten oder auf dem neuen Windows-Gerät Windows PowerShell 5.1 (64 Bit) als Administrator.</li>
<li>Führen Sie den passenden Befehlsblock unten aus. Er lädt das Installationsskript per HTTPS vom Server und startet es.</li>
<li>Fügen Sie den oben angezeigten Einmalcode ein, sobald das Skript nach <strong>Einmalcode</strong> (Linux) oder <strong>One-time enrollment token</strong> (Windows) fragt. Bestätigen Sie mit Enter. Eine vorherige Passwortabfrage von <code>sudo</code> gehört zur Anmeldung mit Administratorrechten.</li>
<li>Prüfen Sie nach der Installation, ob das neue Gerät unter <a href="#geraete">Geräte</a> beim gewählten Kunden erscheint.</li>
</ol>
<label className="check"><input type="checkbox" checked={adminScripts} onChange={e => setAdminScripts(e.target.checked)}/>
Installationsbefehle für Administratorskripte anzeigen
</label>
{adminScripts && <p>Der lokale Installer aktiviert mit <code>--enable-admin-scripts</code> unter Linux oder <code>-EnableAdministratorScripts</code> unter Windows den Skript-Helper.
{' '}Für jeden Auftrag gelten zusätzlich die Skript- und Administratorrechte des Kunden und die Genehmigung in der WebUI.</p>}
{!enrollment && <p className="muted">Die Downloadlinks und Befehle erscheinen hier, sobald ein Einmalcode angezeigt wird.</p>}
{enrollment && !origin && <p role="status">Für die Geräteaufnahme ist keine HTTPS-Downloadadresse konfiguriert.</p>}
{origin && !linuxInstaller && !windowsInstaller && <p role="status">Für diesen Kunden ist derzeit kein Linux- oder Windows-Installer verfügbar.</p>}
{linuxInstaller && <>
<h4>Linux ({availableLinuxArchitectures.join(' und ')})</h4>
<p>Installationsskript <a href={linuxInstaller} target="_blank" rel="noopener noreferrer">linux.sh</a></p>
<pre>{`curl --fail --show-error --silent '${linuxInstaller}' -o linux.sh && sudo sh linux.sh '${origin}'${adminScripts ? ' --enable-admin-scripts' : ''}`}</pre>
</>}
{windowsInstaller && <>
<h4>Windows (x64)</h4>
<p>Installationsskript <a href={windowsInstaller} target="_blank" rel="noopener noreferrer">windows.ps1</a>{windowsPlatforms.length > 1 && '. Führen Sie einen der beiden Befehlsblöcke aus.'}</p>
{windowsPlatforms.map(platform => <div key={platform}>
{windowsPlatforms.length > 1 && <p>{platform.endsWith('-gnu') ? 'GNU' : 'MSVC'}</p>}
<pre>{`Invoke-WebRequest -UseBasicParsing '${windowsInstaller}' -OutFile .\\windows.ps1
.\\windows.ps1 -BootstrapBase '${origin}' -Platform '${platform}'${adminScripts ? ' -EnableAdministratorScripts' : ''}`}</pre>
</div>)}
</>}
</article>
</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 allScripts = payloads.length > 0 && payloads.every(p => record(p.action).action === 'run_script');
const blockers = reviewBlockers(data);
if (!allScripts) blockers.push('Dieser Plan enthält eine frühere Aktionsart. Erstellen Sie für die Ausführung einen neuen Skriptauftrag.');
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') {
if (!allScripts) throw new Error('Neue Geräteaufträge führen ausschließlich Skripte aus.');
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 !== 'reject' && 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 && missingRights.length > 0 && <p className="warning">Für die Einreichung fehlen Rechte: {missingRights.join(', ')}.</p>}
{mode === 'submit' && !data.approval_state && allowed(auth, 'operations:submit') &&
<button className="primary" disabled={busy || !!plan.error || !!blockers.length || !!missingRights.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 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' || route.tab === 'wartung') ? <>
<a href="#auftraege" className="back-link">← Zu den Aufträgen</a>
<OrderComposer tenantId={customer} customerName={customerName} auth={scoped} initialAssetIds={selected} onSubmitted={afterSubmission} />
</> : 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') && allowed(scoped, 'scripts:execute') && <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' && (
<>
<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>);