Separate script publishing, job assignment and interactive approval in the WebUI

This commit is contained in:
2026-11-17 22:42:31 +01:00
parent 2100e6a4ce
commit 477a63f20e
13 changed files with 1027 additions and 294 deletions
+84 -106
View File
@@ -1,113 +1,91 @@
import React, { FormEvent, useEffect, useState } from 'react';
import { objectId, page, record, request, Session, tenantPath, text } from './api';
import { useState, type FormEvent } from 'react';
import { ApiError, request, tenantPath, type Session } from './api';
import { allowed } from './safety';
import { windowsUpdateScriptHash } from './script-console';
import { ErrorBox, errorText, useResource } from './resource';
import { identityNames, interpreterNames, latestRevisions, loadRevisions, parseRevision, type Identity, type Interpreter, type Revision, type Script } from './script-catalog';
import './script-workspace.css';
interface Draft {
name: string;
interpreter: 'posix_sh' | 'bash' | 'powershell';
execution_identity: 'agent_service' | 'root' | 'system';
script_utf8: string;
export function ScriptFields({ script, change, ids, interpreters }: {
script: Script; change: (next: Script) => void; ids: Identity[]; interpreters?: Interpreter[];
}) {
const possible = ids.filter(id => id === 'agent_service' || id === (script.interpreter === 'powershell' ? 'system' : 'root'));
return <>
<div className="work-fields"><label>Plattform und Interpreter
<select value={script.interpreter} onChange={e => change({...script, interpreter: e.target.value as Interpreter, execution_identity: 'agent_service'})}>
{Object.entries(interpreterNames).filter(([key]) => !interpreters || interpreters.includes(key as Interpreter)).map(([value, label]) => <option value={value} key={value}>{label}</option>)}
</select></label>
<label>Ausführen als<select value={script.execution_identity} onChange={e => change({...script, execution_identity: e.target.value as Identity})}>
{possible.map(id => <option key={id} value={id}>{identityNames[id]}</option>)}
</select></label>
</div>
{script.execution_identity !== 'agent_service' && <p className="warning">Dieses Skript fordert {identityNames[script.execution_identity]}-Rechte auf den Zielgeräten an.</p>}
<label>Skriptinhalt<textarea className="script-editor" spellCheck={false} required rows={10} value={script.script_utf8}
onChange={e => change({...script, script_utf8: e.target.value})}/></label>
{script.interpreter === 'powershell' && /[^\x00-\x7f]/.test(script.script_utf8) && !script.script_utf8.startsWith('\ufeff') &&
<p className="warning">Windows PowerShell 5.1 benötigt für diesen Text eine UTF-8-Signatur. <button type="button" className="link" onClick={() => change({...script, script_utf8: '\ufeff' + script.script_utf8})}>UTF-8-Signatur hinzufügen</button></p>}
</>;
}
interface Revision extends Draft { revision_id: string; version: number; script_sha256: string }
const blank: Draft = { name: '', interpreter: 'posix_sh', execution_identity: 'agent_service', script_utf8: '' };
function revision(input: unknown): Revision {
const row = record(input);
if ((row.interpreter !== 'posix_sh' && row.interpreter !== 'bash' && row.interpreter !== 'powershell') ||
(row.execution_identity !== 'agent_service' && row.execution_identity !== 'root' && row.execution_identity !== 'system') ||
typeof row.version !== 'number' || !Number.isSafeInteger(row.version) || row.version < 1) throw Error('Ungültige Skriptversion');
return { name: text(row.name, 'Name'), interpreter: row.interpreter, execution_identity: row.execution_identity,
script_utf8: text(row.script_utf8, 'Skript'), revision_id: objectId(row, 'revision'), version: row.version,
script_sha256: text(row.script_sha256, 'SHA256') };
}
export function ScriptLibrary({ tenantId, auth, selected, showPlan }: { tenantId: string; auth: Session; selected: string[]; showPlan: (id: string) => void }) {
const path = tenantPath(tenantId, '/script-revisions');
const canRead = allowed(auth, 'operations:read'), canPlan = allowed(auth, 'operations:plan') && allowed(auth, 'scripts:execute');
const [items, setItems] = useState<Revision[]>([]), [cursor, setCursor] = useState<string | null>(null);
const [chosen, setChosen] = useState(''), [draft, setDraft] = useState<Draft | null>(null), [base, setBase] = useState(0);
const [busy, setBusy] = useState(false), [error, setError] = useState(''), [notice, setNotice] = useState('');
const stored = items.find(row => row.revision_id === chosen);
useEffect(() => {
if (!canRead) return;
const controller = new AbortController();
setBusy(true);
request(path, { signal: controller.signal }).then(value => {
if (controller.signal.aborted) return;
const result = page(value), rows = result.items.map(revision);
setItems(rows); setCursor(result.next_cursor); setChosen(rows[0]?.revision_id ?? '');
}).catch(err => { if (!controller.signal.aborted) setError(String(err)); })
.finally(() => { if (!controller.signal.aborted) setBusy(false); });
return () => controller.abort();
}, [path, canRead]);
async function action(work: () => Promise<void>) {
setBusy(true); setError(''); setNotice('');
try { await work(); } catch (err) { setError(err instanceof Error ? err.message : String(err)); }
finally { setBusy(false); }
export function ScriptLibrary({ tenantId, auth }: { tenantId: string; auth: Session }) {
const read = allowed(auth, 'operations:read');
const canPublish = allowed(auth, 'operations:plan') && allowed(auth, 'scripts:execute');
const library = useResource(signal => read ? loadRevisions(tenantId, signal) : Promise.resolve([]), [tenantId, read]);
const [opened, open] = useState('');
const [draft, setDraft] = useState<Script | null>(null);
const [base, setBase] = useState(0);
const [busy, setBusy] = useState(false);
const [error, setError] = useState<string | null>(null);
const [notice, setNotice] = useState('');
const versions = (library.data ?? []).filter(item => item.name === opened);
const latest = versions[0];
function edit(existing?: Revision) {
setBase(existing?.version ?? 0);
setDraft(existing ? { ...existing } : { name: '', interpreter: 'posix_sh', execution_identity: 'agent_service', script_utf8: '' });
setError(null); setNotice('');
}
async function more() {
const result = page(await request(path + '?cursor=' + encodeURIComponent(cursor!)));
const rows = result.items.map(revision);
setItems(old => [...old, ...rows.filter(row => !old.some(saved => saved.revision_id === row.revision_id))]); setCursor(result.next_cursor);
}
async function save(e: FormEvent) {
async function publish(e: FormEvent) {
e.preventDefault();
if (!draft) return;
await action(async () => {
const saved = revision(await request(path, { csrf: auth.csrf_token, body: { ...draft, expected_version: base } }));
setItems(old => [...old.filter(row => row.revision_id !== saved.revision_id), saved]); setChosen(saved.revision_id);
setDraft(null); setNotice(`Version ${saved.version} gespeichert.`);
});
if (!draft || busy) return;
setBusy(true); setError(null);
try {
const {name, interpreter, execution_identity, script_utf8} = draft;
const saved = parseRevision(await request(tenantPath(tenantId, '/script-revisions'), {
csrf: auth.csrf_token, body: {name: name.trim(), interpreter, execution_identity, script_utf8, expected_version: base}
}));
open(saved.name); setDraft(null); setNotice(`Version ${saved.version} veröffentlicht.`); library.reload();
} catch (err) {
setError(err instanceof ApiError && err.code === 'SCRIPT_REVISION_CONFLICT'
? 'Unter diesem Namen gibt es bereits eine neuere Version. Öffnen Sie den aktuellen Stand vor dem Veröffentlichen.' : errorText(err));
if (err instanceof ApiError && err.status === 409) library.reload();
} finally { setBusy(false); }
}
function edit(row?: Revision) {
setBase(row?.version ?? 0);
setDraft(row ? { name: row.name, interpreter: row.interpreter, execution_identity: row.execution_identity, script_utf8: row.script_utf8 } : { ...blank });
setError(''); setNotice('');
}
async function plan(e: FormEvent<HTMLFormElement>) {
e.preventDefault();
if (!stored || !selected.length) return;
const form = new FormData(e.currentTarget);
await action(async () => {
const now = Date.now(), expires = now + Number(form.get('minutes')) * 60000;
const body = { targets: { asset_ids: selected }, reason: String(form.get('reason')),
schedule: { not_before: new Date(now).toISOString(), start_before: new Date(expires).toISOString() },
rollout: { max_parallel: 1, halt_after_failures: 1 }, max_runtime_seconds: Number(form.get('runtime')), max_output_bytes: 65536 };
const result = record(await request(path + '/' + encodeURIComponent(stored.revision_id) + '/plan', { csrf: auth.csrf_token, body }));
showPlan(objectId(result, 'plan')); setNotice('Plan zur Prüfung geöffnet.');
});
}
if (!canRead) return null;
const windowsUpdate = stored?.execution_identity === 'system' && stored.interpreter === 'powershell' && stored.script_sha256 === windowsUpdateScriptHash;
const limit = windowsUpdate ? 3600 : stored?.execution_identity === 'system' ? 120 : stored?.execution_identity === 'root' ? 300 : 3600;
return <section aria-label="Skriptbibliothek"><h2>Skriptbibliothek</h2>
{error && <p role="alert" className="error">{error}</p>}{notice && <p role="status">{notice}</p>}
{items.length > 0 && <label>Gespeicherte Skriptversion<select value={chosen} disabled={busy || !!draft} onChange={e => setChosen(e.target.value)}>
{[...items].sort((a,b) => a.name.localeCompare(b.name) || b.version - a.version).map(row => <option key={row.revision_id} value={row.revision_id}>{row.name} · v{row.version}</option>)}
</select></label>}
{cursor && <button disabled={busy || !!draft} onClick={() => void action(more)}>Weitere Versionen laden</button>}
{stored && !draft && <><p>{stored.interpreter === 'powershell' ? 'Windows PowerShell' : stored.interpreter === 'bash' ? 'Linux bash' : 'Linux sh'} · {stored.execution_identity} · SHA256 <code>{stored.script_sha256}</code></p>
<details><summary>Gespeicherten Skripttext anzeigen</summary><pre>{stored.script_utf8}</pre></details></>}
{canPlan && !draft && <div><button disabled={busy} onClick={() => edit()}>Neues Skript</button>
{stored && <button disabled={busy} onClick={() => edit(stored)}>Neue Version bearbeiten</button>}</div>}
{draft && <form onSubmit={save}><fieldset disabled={busy}><legend>{base ? `Neue Version von ${draft.name}` : 'Neues Skript'}</legend>
<label>Name<input required maxLength={120} readOnly={base > 0} value={draft.name} onChange={e => setDraft({...draft,name:e.target.value})}/></label>
<label>Interpreter<select value={draft.interpreter} onChange={e => setDraft({...draft,interpreter:e.target.value as Draft['interpreter'],execution_identity:'agent_service'})}>
<option value="posix_sh">Linux sh</option><option value="bash">Linux bash</option><option value="powershell">Windows PowerShell</option></select></label>
<label>Ausführungsidentität<select value={draft.execution_identity} onChange={e => setDraft({...draft,execution_identity:e.target.value as Draft['execution_identity']})}>
<option value="agent_service">agent_service</option>{draft.interpreter === 'powershell' ? <option value="system">system</option> : <option value="root">root</option>}</select></label>
<label>Skripttext<textarea required rows={9} value={draft.script_utf8} onChange={e => setDraft({...draft,script_utf8:e.target.value})}/></label>
<button>Version speichern</button><button type="button" onClick={() => setDraft(null)}>Abbrechen</button>
</fieldset></form>}
{canPlan && stored && !draft && <form key={stored.revision_id} onSubmit={plan}><fieldset disabled={busy}><legend>Auftrag für {stored.name} · v{stored.version} vorbereiten</legend>
<p>{selected.length} ausgewählte Geräte · Ein Gerät gleichzeitig · Stopp beim ersten Fehler · 65536 Byte Ausgabe je Gerät</p>
{windowsUpdate && <p>Diese Version installiert verfügbare Softwareupdates ohne eigenen Neustart. Sie meldet Neustartbedarf. Laufzeiten über 120 Sekunden erfordern die passende Windows-Update-Freigabe in Server- und Helperpolicy.</p>}
<label>Begründung<input name="reason" required maxLength={1024}/></label>
<label>Startfrist in Minuten<input name="minutes" type="number" min={1} max={1440} defaultValue={60} required/></label>
<label>Laufzeit je Gerät in Sekunden<input name="runtime" type="number" min={1} max={limit} defaultValue={windowsUpdate ? 3600 : Math.min(limit,120)} required/></label>
<button disabled={!selected.length}>Plan vorbereiten</button>
</fieldset></form>}
</section>;
return <>
<div className="page-title"><h1>Skripte</h1>
{canPublish && !draft && !opened && <button className="primary" onClick={() => edit()}>Neues Skript</button>}
</div>
<ErrorBox error={error ?? library.error}/>{notice && <p role="status">{notice}</p>}
{!read ? <p>Die Berechtigung zum Lesen der Skriptbibliothek fehlt.</p> :
draft ? <section><h2>{base ? 'Neue Version' : 'Neues Skript'}</h2><form onSubmit={publish}>
<fieldset className="work-form" disabled={busy}><label>Name<input autoFocus required maxLength={120} readOnly={base > 0} value={draft.name} onChange={e => setDraft({...draft,name:e.target.value})}/></label>
<ScriptFields script={draft} change={setDraft} ids={['agent_service','root','system']}/>
<div className="work-actions"><button type="button" onClick={() => {setError(null); setDraft(null);}}>Abbrechen</button><button className="primary" type="submit">Version veröffentlichen</button></div>
</fieldset>
</form></section> :
opened ? <section><button className="link" onClick={() => {open(''); setNotice('');}}>Zur Skriptbibliothek</button>
{latest ? <><div className="section-heading"><h2>{latest.name}</h2>{canPublish && <button onClick={() => edit(latest)}>Neue Version</button>}</div>
<p>{interpreterNames[latest.interpreter]} · Version {latest.version} · {identityNames[latest.execution_identity]}</p>
<pre className="script-body">{latest.script_utf8}</pre>
{versions.length > 1 && <details><summary>Frühere Versionen ({versions.length - 1})</summary>
{versions.slice(1).map(item => <details key={item.revision_id}><summary>Version {item.version} · {interpreterNames[item.interpreter]} · {identityNames[item.execution_identity]}</summary><pre className="script-body">{item.script_utf8}</pre></details>)}
</details>}</> : <p role="status">Skript wird geladen …</p>}
</section> :
<section aria-label="Skriptbibliothek">
{!library.data ? <p role="status">Bibliothek wird geladen …</p> : library.data.length ? <div className="table"><table>
<thead><tr><th>Name</th><th>Plattform</th><th>Version</th><th>Ausführen als</th></tr></thead>
<tbody>{latestRevisions(library.data).map(item => <tr key={item.name}>
<td><button className="link" onClick={() => {open(item.name); setNotice('');}}>{item.name}</button></td>
<td>{interpreterNames[item.interpreter]}</td><td>{item.version}</td><td>{identityNames[item.execution_identity]}</td>
</tr>)}</tbody>
</table></div> : <p>Für diesen Kunden sind noch keine Skripte veröffentlicht.</p>}
</section>}
</>;
}