import { useEffect, useState } from 'react';
import {
ApiError,
objectId,
page,
pretty,
record,
request,
session,
tenantPath,
type RecordValue,
type Session,
type Tenant
} from './api';
import { AdminControl } from './management';
import { allowed } from './safety';
import { CatalogCheckNotice } from './catalog-check';
import { devicePlatform } from './script-catalog';
import { DeviceInventoryPanels, systemDetails } from './device-inventory';
import { OPNsenseDetails } from './opnsense';
import { ProxmoxDetails } from './proxmox';
import { DeviceCustomerTransfer } from './device-customer-transfer';
import { HypervisorAssignment, HypervisorLabel } from './device-hypervisor';
import { groupDevices, type FleetGroup, type RowRole } from './device-groups';
import { ErrorBox, errorText, useResource } from './resource';
import { NavIcon, orderDetailRoute } from './navigation';
import { orderTitle, Status } from './order-presentation';
import { RecoveryReview, recoveryAsset, recoveryTenant } from './recovery-review';
import { EchoProbeReview } from './echo-probe-review';
import { EchoCompletionReview } from './echo-completion-review';
import { SyncAlignmentReview } from './sync-alignment-review';
import { SystemNonstartReview } from './system-nonstart-review';
const unknown = 'Nicht gemeldet';
const noPurpose = 'Nicht hinterlegt';
const plural = (n: number, one: string, many: string) => `${n} ${n === 1 ? one : many}`;
function groupName(group: FleetGroup) {
return group.kind === 'hypervisor' ? 'Hypervisor ' + (group.title || 'unbekannt')
: group.kind === 'hetzner' ? 'Hetzner Cloud'
: group.kind === 'physical' ? 'Physische Geräte' : 'Nicht zugeordnet';
}
/** How a listed virtual machine got its place under a registered hypervisor. */
function linkSource(d: RecordValue) {
if (!d.hypervisor || typeof d.hypervisor !== 'object') return '';
const info = record(d.hypervisor);
return info.kind !== 'device' ? '' : info.source === 'proxmox' ? 'automatisch erkannt' : 'manuell zugeordnet';
}
function GroupHeader({ group, showCustomer }: { group: FleetGroup; showCustomer: boolean }) {
const guests = group.rows.filter((r) => r.role !== 'host').length;
const machines = plural(guests, 'virtuelle Maschine', 'virtuelle Maschinen');
const [icon, eyebrow, title, facts] =
group.kind === 'hypervisor'
? (['server', 'Hypervisor',
group.hostPath ? {group.title || 'Unbekannter Host'} : group.title || 'Unbekannter Host',
[guests ? machines : 'Keine zugeordneten virtuellen Maschinen',
!group.hostListed && 'Host in dieser Ansicht nicht enthalten',
showCustomer && group.customer]] as const)
: group.kind === 'hetzner'
? (['cloud', 'Externer Anbieter', 'Hetzner Cloud', [machines, 'Platzhalter, kein Gerät im Bestand']] as const)
: group.kind === 'physical'
? (['geraete', 'Eigene Hardware', 'Physische Geräte', [plural(guests, 'Gerät', 'Geräte')]] as const)
: (['offen', 'Ohne Zuordnung', 'Nicht zugeordnet',
[plural(guests, 'Gerät', 'Geräte'), 'kein Hypervisor oder Gerätetyp erkannt']] as const);
return (
{eyebrow}
{title}
{facts.filter(Boolean).map((fact, i) => {fact} )}
);
}
const number = new Intl.NumberFormat('de-DE', { maximumFractionDigits: 1 });
const date = new Intl.DateTimeFormat('de-DE', { dateStyle: 'medium', timeStyle: 'short' });
function label(value: unknown) {
return typeof value === 'string' && value.trim() ? value : unknown;
}
function time(value: unknown) {
const t = typeof value === 'string' ? Date.parse(value) : NaN;
return Number.isFinite(t) ? date.format(t) : unknown;
}
function gib(v: unknown) {
return typeof v === 'number' && Number.isFinite(v) && v >= 0 ? number.format(v / 2 ** 30) : null;
}
function capacity(free: unknown, total: unknown) {
if (typeof total !== 'number' || !Number.isFinite(total) || total <= 0)
return { text: unknown, usedPercent: null };
const used = typeof free === 'number' && free >= 0 && free <= total ? total - free : null;
return {
text: `${gib(used) ?? '–'} / ${gib(total)} GiB`,
usedPercent: used === null ? null : (used / total) * 100
};
}
function cpuUsage(value: unknown) {
return typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 100
? `${number.format(value)} %`
: unknown;
}
function measuredAt(value: unknown) {
const observed = time(value);
return observed === unknown ? undefined : `Gemessen am ${observed}`;
}
function cpu(d: RecordValue) {
const model = label(d.cpu_model),
count = d.cpu_logical_count;
const threads =
typeof count === 'number' && count > 0 ? `${count} log. CPU${count === 1 ? '' : 's'}` : '';
return {
primary: model === unknown ? threads || unknown : model,
secondary: model === unknown ? '' : threads
};
}
const states: Record = {
online: 'Online',
offline: 'Offline',
never_seen: 'Ohne Erstkontakt',
revoked: 'Widerrufen',
archived: 'Archiviert',
replaced: 'Ersetzt',
unverified: 'Identität unbestätigt'
};
function Presence({ d }: { d: RecordValue }) {
const state =
typeof d.lifecycle === 'string' && d.lifecycle !== 'current' ? d.lifecycle : String(d.status);
return (
{states[state] ?? 'Unbekannt'}
);
}
function Capacity({ free, total }: {
free: unknown;
total: unknown;
}) {
const { text, usedPercent } = capacity(free, total);
const displayUsed = usedPercent === null ? null : Math.round(usedPercent * 10) / 10;
const usedLabel = displayUsed === null ? '' : `${number.format(displayUsed)} % belegt`;
const breakdown = displayUsed === null ? '' : `${usedLabel}, ${number.format(100 - displayUsed)} % frei`;
return (
<>
{text}
{usedPercent !== null && (
<>
{usedLabel}
>
)}
>
);
}
function LinuxDisk({ disk, groups }: { disk: RecordValue; groups: string[] }) {
const { used_bytes: used, available_bytes: free, total_bytes: total } = disk;
const size = typeof total === 'number' && Number.isFinite(total) && total > 0 ? total : null;
const valid = size !== null && typeof used === 'number' && used >= 0 && typeof free === 'number' && free >= 0 && used + free <= size;
const usedPct = valid ? used / size * 100 : 0, freePct = valid ? free / size * 100 : 0;
const summary = valid ? `${number.format(usedPct)} % belegt, ${number.format(freePct)} % frei, ${number.format(Math.max(0,100-usedPct-freePct))} % nicht zugeordnet` : 'Belegung nicht ermittelbar';
const group = disk.kind === 'group';
return
{group ? 'Verbund: ' : ''}{label(disk.name)}
{typeof disk.model === 'string' &&
{disk.model} }
{group && Array.isArray(disk.members) && disk.members.length > 0 &&
{disk.members.filter(v => typeof v === 'string').join(', ')} }
{!group && groups.length > 0 &&
Im Verbund: {groups.join(', ')} }
{size === null ? 'Größe nicht gemeldet' : `${valid ? gib(used) : '–'} / ${gib(size)} GiB`}
{size !== null &&
}
{valid ? `${number.format(usedPct)} % belegt` : summary}
;
}
function DiskCapacity({ device }: { device: RecordValue }) {
if ('disks' in device) {
const disks = Array.isArray(device.disks) ? device.disks.filter(d => d && typeof d === 'object' && ['disk','group'].includes(d.kind) && typeof d.name === 'string') : [];
return <>{disks.length ? disks.map((disk,i) => g.kind === 'group' && Array.isArray(g.members) && g.members.includes(disk.name)).map(g => g.name) : []}/>) :
Keine Festplatten gemeldet }
{device.disks_truncated === true && Liste gekürzt }>;
}
// Only Windows fleet rows use drive letters. Linux mount inventories remain
// available in the detail view, without expanding every fleet row.
const drives = Array.isArray(device.volumes)
? device.volumes.map(v => record(v)).filter(v => typeof v.name === 'string' && /^[A-Z]:$/.test(v.name)) : [];
if (!drives.length) return <>{device.source_id === 'linux.base' && Root-Dateisystem / }
>;
return <>{drives.map(drive => (
{String(drive.name)} {' '}
))}>;
}
type Target = { customer: string; ids: string[] };
type Props = {
detailPath: string;
auth: Session;
customers: Tenant[];
filter: string;
onFilter: (id: string) => void;
selection: Target;
onSelection: (s: Target) => void;
onCreateOrder: () => void;
onEnroll: () => void;
onOperation: (customer: string, id: string, jobId: string) => void;
};
function devicePath(customer: string, asset: string) {
return tenantPath(customer, '/devices/' + encodeURIComponent(asset));
}
function DevicePurpose({ value, path, customer, editor, success, onSaved }: {
value: string;
path: string;
customer: string;
editor: Session | null;
success: boolean;
onSaved: () => void;
}) {
const [draft, setDraft] = useState(null);
const [busy, setBusy] = useState(false);
const [error, setError] = useState(null);
const tooLong = Array.from(draft?.trim() ?? '').length > 500;
const close = () => { setDraft(null); setError(null); };
return (
Zweck
{editor && draft !== null ? (
) : (
<>
{value || noPurpose}
{editor && setDraft(value)}>Zweck bearbeiten }
{success && Zweck gespeichert.
}
>
)}
);
}
function reportedScriptProfiles(device: RecordValue) {
const os = devicePlatform(device);
if (!os || !Array.isArray(device.capabilities)) return 'Nicht gemeldet';
const caps = new Set(device.capabilities);
if (!caps.has('run_script')) return 'Nicht gemeldet';
const windows = os === 'windows';
const identity = windows ? 'system' : 'root';
const service = os==='opnsense' && !caps.has('opnsense.posix/1') ? 'Kernelabfrage als Dienstkonto' : windows ? 'PowerShell als Dienstkonto' : 'Shell als Dienstkonto';
if (!caps.has(os + '.base/1') || caps.has(windows ? 'linux.base/1' : 'windows.base/1')) return 'Nicht gemeldet';
if (windows && !['rmm.sync.v1', 'script.powershell/1', 'script.powershell.process_remote_signed/1'].every(cap => caps.has(cap)))
return 'Nicht gemeldet';
const admin = ['rmm.sync.v1', 'script.full_maintenance/1', 'helper.' + identity + '.v1', identity + ':run_script']
.every(capability => caps.has(capability));
return admin ? service + ' und als Administrator (' + (windows ? 'SYSTEM' : 'root') + ')' : service;
}
function DeviceDetail({
customer,
asset,
agent,
auth,
customers,
back,
openOperation,
changed
}: {
customer: string;
asset: string;
agent: string;
auth: Session;
customers: Tenant[];
back: () => void;
openOperation: (id: string, jobId: string) => void;
changed: (notice?: string) => void;
}) {
const path = devicePath(customer, asset);
const detail = useResource(
async (signal) => record(await request(path + '?agent_id=' + encodeURIComponent(agent), { signal })),
[customer, asset, agent],
true
);
const membership = useResource(
async (signal) => session(await request('/auth/session', { signal, tenantId: customer })),
[customer, auth.principal.id]
);
const [busy, setBusy] = useState(false),
[error, setError] = useState(null);
const [confirmDelete, setConfirmDelete] = useState(false);
const [managing, setManaging] = useState(false);
const [purposeSaved, setPurposeSaved] = useState(false);
const d = detail.data;
const scoped = membership.data;
const volumes = Array.isArray(d?.volumes) ? d.volumes.map((v) => record(v)) : [];
const jobs = Array.isArray(d?.recent_jobs) ? d.recent_jobs.map((v) => record(v)) : null;
const facts = d && [
['Kunde', label(d.customer_name)],
['Type', label(d.device_type)],
['Betriebssystem', label(d.os)],
...systemDetails(d, time),
['RAM belegt / gesamt', capacity(d.ram_available_bytes, d.ram_total_bytes).text],
['CPU', [cpu(d).primary, cpu(d).secondary].filter(Boolean).join(' · ')],
['CPU-Auslastung', [cpuUsage(d.cpu_usage_percent), measuredAt(d.cpu_usage_observed_at)].filter(Boolean).join(' · ')],
['Speicher belegt / gesamt', capacity(d.disk_free_bytes, d.disk_total_bytes).text],
['Letzter Kontakt', time(d.last_contact_at)],
['Inventar erhoben', time(d.observed_at)],
['Agentversion', label(d.agent_version)],
['Vom Agenten gemeldete Skriptausführung', reportedScriptProfiles(d)]
];
return (
Zur Geräteliste
{!d && !detail.error &&
Inventar wird geladen …
}
{d && (
<>
Geräteinformationen
{facts?.map(([k, v]) => (
{k}
{v}
))}
{ setPurposeSaved(true); detail.reload(); }}
/>
{volumes.length > 0 && (
Laufwerke
Laufwerk
Speicher belegt / gesamt
{volumes.map((v, i) => (
{label(v.name)}
{capacity(v.free_bytes, v.total_bytes).text}
))}
)}
{jobs && (
Letzte Aufträge
{jobs.length === 0 ? (
Keine Aufträge für dieses Gerät.
) : (
)}
)}
Technische Daten
{pretty(d)}
{scoped && allowed(scoped, 'devices:revoke') &&
d.tenant_id === customer && d.asset_id === asset && d.agent_id === agent && (
setManaging(e.currentTarget.open)}>
Gerät verwalten
{d.device_type === 'virtual' && d.lifecycle === 'current' &&
}
{['archived', 'current'].includes(String(d.lifecycle)) && (
{
setBusy(true);
setError(null);
try {
await request(path + '/archive', {
csrf: scoped.csrf_token,
body: { archived: d.lifecycle !== 'archived' }
});
changed();
} catch (e) {
setError(errorText(e));
} finally {
setBusy(false);
}
}}
>
{d.lifecycle === 'archived'
? 'Zurück in den Bestand'
: 'In die Historie verschieben'}
)}
{d.lifecycle !== 'revoked' && (
)}
{d.lifecycle === 'revoked' && (confirmDelete ? (
Die Kopplung von {label(d.hostname)} bei {label(d.customer_name)}
{' '}wird mit ihrem Inventar und ihren Geräteergebnissen dauerhaft gelöscht.
Andere Installationen bleiben erhalten.
Kopplungs-ID {agent}
{
setBusy(true);
setError(null);
try {
await request(path + '?agent_id=' + encodeURIComponent(agent), {
method: 'DELETE', csrf: scoped.csrf_token, tenantId: customer
});
changed(`Kopplung von „${label(d.hostname)}“ bei „${label(d.customer_name)}“ gelöscht.`);
} catch (e) {
if (e instanceof ApiError && e.code === 'DEVICE_HAS_OPEN_WORK') {
setError('Für diese Kopplung gibt es offene Aufträge oder Genehmigungen. Prüfen Sie diese vor dem Löschen.');
} else if (e instanceof ApiError && e.code === 'DEVICE_REVOCATION_REQUIRED') {
setError('Widerrufen Sie diese Geräteidentität vor dem Löschen.');
} else {
setError(errorText(e));
}
} finally {
setBusy(false);
}
}}>Endgültig löschen
{
setConfirmDelete(false);
setError(null);
}}>Abbrechen
) : (
setConfirmDelete(true)}>Kopplung löschen
))}
)}
{scoped?.principal.simulated &&
customer === recoveryTenant &&
asset === recoveryAsset &&
allowed(scoped, 'inventory:read') && (
Entwicklungsabnahmen
)}
>
)}
);
}
export function Devices({
detailPath,
auth,
customers,
filter,
onFilter,
selection,
onSelection,
onEnroll,
onCreateOrder,
onOperation
}: Props) {
const [search, setSearch] = useState(''),
[query, setQuery] = useState(''),
[status, setStatus] = useState(''),
[history, setHistory] = useState(false);
const [deletionNotice, setDeletionNotice] = useState('');
const [trail, setTrail] = useState<{ filter: string; routes: string[] }>({ filter, routes: [] });
const routes = trail.filter === filter ? trail.routes : [];
function setRoutes(next: string[] | ((old: string[]) => string[])) {
setTrail(old => ({ filter, routes: typeof next === 'function' ? next(old.filter === filter ? old.routes : []) : next }));
}
const [customerId, assetId, agentId] = detailPath.split('/');
const target =
customerId && assetId && agentId ? { customer: customerId, asset: assetId, agent: agentId } : null;
const back = () => {
window.location.hash = 'geraete';
};
const cursor = routes[routes.length - 1];
useEffect(() => {
const timer = setTimeout(() => {
setQuery(search.trim());
setRoutes([]);
}, 200);
return () => clearTimeout(timer);
}, [search]);
useEffect(() => setTrail({ filter, routes: [] }), [filter]);
const list = useResource(
async (signal) => {
if (target) return null;
const params = new URLSearchParams({ view: history ? 'history' : 'current', limit: '40' });
if (query) params.set('q', query);
if (status && !history) params.set('status', status);
if (cursor) params.set('cursor', cursor);
const path = filter ? tenantPath(filter, '/devices') : '/api/v1/devices';
return page(await request(path + '?' + params, { signal }));
},
[filter, query, history, status, cursor, detailPath],
true
);
function setView(historic: boolean) {
setRoutes([]);
setHistory(historic);
onSelection({ customer: '', ids: [] });
}
function select(d: RecordValue, checked: boolean) {
const asset = objectId(d, 'asset'),
customer = objectId(d, 'tenant');
if (checked && selection.ids.length && customer !== selection.customer) return;
const ids = checked ? [...selection.ids, asset] : selection.ids.filter((id) => id !== asset);
onSelection({ customer: ids.length ? customer : '', ids });
}
if (target)
return (
onOperation(target.customer, id, jobId)}
changed={(notice) => {
setDeletionNotice(notice ?? '');
back();
setRoutes([]);
onSelection({ customer: '', ids: [] });
list.reload();
}}
/>
);
const columns = ['Hostname', 'Type', 'Zweck', 'OS', 'Status', 'Speicher belegt / gesamt', 'RAM belegt / gesamt', 'CPU', 'Kunde'];
const row = (d: RecordValue, role: RowRole | 'flat') => {
const asset = objectId(d, 'asset'),
agent = objectId(d, 'agent'),
customer = objectId(d, 'tenant'),
model = cpu(d),
purpose = typeof d.purpose === 'string' ? d.purpose : '';
const show = () => {
setDeletionNotice('');
window.location.hash = ['geraete', customer, asset, agent]
.map(encodeURIComponent)
.join('/');
};
const another = selection.ids.length > 0 && selection.customer !== customer;
return (
{!history && (
e.stopPropagation()}>
select(d, e.target.checked)}
/>
)}
{
e.stopPropagation();
show();
}}
>
{label(d.hostname)}
{role === 'flat' && }
{role === 'guest' && linkSource(d) && {linkSource(d)} }
{label(d.device_type)}
{purpose || noPurpose}
{label(d.os)}
{d.status === 'offline' && d.lifecycle === 'current' && (
Zuletzt {time(d.last_contact_at)}
)}
{model.primary}
{model.secondary && {model.secondary} }
Auslastung {cpuUsage(d.cpu_usage_percent)}
{label(d.customer_name)}
);
};
/** Every block shares these column widths, so the blocks line up under one heading. */
const table = (rows: { device: RecordValue; role: RowRole | 'flat' }[], heading: 'visible' | 'hidden' | 'only') => (
{!history && }
{columns.map((h) => )}
{!history && (
Ziel auswählen
)}
{columns.map((h) => (
{h}
))}
{heading !== 'only' && {rows.map((r) => row(r.device, r.role))} }
);
return (
<>
Geräte
{allowed(auth, 'devices:enroll') && (
Gerät aufnehmen
)}
{deletionNotice && {deletionNotice}
}
{
if (history) setView(false);
}}
>
Bestand
{
if (!history) setView(true);
}}
>
Historie
Hostname suchen
setSearch(e.target.value)}
/>
Kunde im Gerätebestand
{
setRoutes([]);
onFilter(e.target.value);
}}
>
Alle Kunden
{customers.map((c) => (
{c.name}
))}
{!history && (
Status
{
setRoutes([]);
setStatus(e.target.value);
}}
>
Jeder Status
Online
Offline
)}
{history && (
Ausgemusterte Geräte und Registrierungen ohne bestätigte Identität.
)}
{!list.data && !list.error && Geräte werden geladen …
}
{list.data && (
<>
{history ? (
table(list.data.items.map((device) => ({ device, role: 'flat' as const })), 'visible')
) : (
!!list.data.items.length && (
{table([], 'only')}
{groupDevices(list.data.items).map((group) => (
{table(group.rows, 'hidden')}
))}
)
)}
{!list.data.items.length && (
{query || filter || status
? 'Keine passenden Geräte'
: 'Keine Geräte in dieser Ansicht'}
{(query || filter || status) && (
{
setSearch('');
setQuery('');
setRoutes([]);
setStatus('');
onFilter('');
}}
>
Filter zurücksetzen
)}
)}
{list.data.items.length} {list.data.items.length === 1 ? 'Gerät' : 'Geräte'}
{cursor || list.data.next_cursor ? ' auf dieser Seite' : ''} · Stand{' '}
{time(list.data.as_of)}
{(cursor || list.data.next_cursor) && (
setRoutes((old) => old.slice(0, -1))}
>
Zurück
{
const next = list.data?.next_cursor;
if (next) setRoutes((old) => [...old, next]);
}}
>
Weiter
)}
>
)}
{!!selection.ids.length && (
{selection.ids.length} {selection.ids.length === 1 ? 'Gerät' : 'Geräte'} ausgewählt
{customers.find((c) => c.tenant_id === selection.customer)?.name}
onSelection({ customer: '', ids: [] })}>
Auswahl aufheben
Auftrag erstellen
)}
>
);
}