feat: snapshot Linux-first RMM MVP and pause handover
Rust development slice / linux (push) Failing after 1m10s
Rust development slice / linux (push) Failing after 1m10s
This commit is contained in:
+125
@@ -0,0 +1,125 @@
|
||||
/** Single JSON boundary. Unknown/partial backend fields remain visible; never synthesize evidence. */
|
||||
export type Json = null | boolean | number | string | Json[] | { [key: string]: Json };
|
||||
export type RecordValue = { [key: string]: unknown };
|
||||
export function record(value: unknown, context = 'Antwort'): RecordValue {
|
||||
if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`CONTRACT_ERROR: ${context} ist kein Objekt`);
|
||||
return value as RecordValue;
|
||||
}
|
||||
export function text(value: unknown, context: string): string {
|
||||
if (typeof value !== 'string' || !value) throw new Error(`CONTRACT_ERROR: ${context} fehlt`);
|
||||
return value;
|
||||
}
|
||||
export function stringField(value: RecordValue, key: string): string { return typeof value[key] === 'string' ? value[key] : 'unknown'; }
|
||||
export interface Tenant { tenant_id: string; name: string }
|
||||
export interface Session { principal: { id: string; display_name: string; simulated: boolean }; tenants: Tenant[]; csrf_token: string; permissions?: string[]; roles?: string[] }
|
||||
export interface Page { items: RecordValue[]; next_cursor: string | null; completeness: string; truncated: boolean; as_of: string }
|
||||
export interface AuthConfig { oidc_configured: boolean; oidc_login_url: '/auth/oidc/login' | null; dev_login_enabled: boolean }
|
||||
export function authConfig(value: unknown): AuthConfig {
|
||||
const r = record(value, 'Auth-Konfiguration');
|
||||
if (typeof r.oidc_configured !== 'boolean' || typeof r.dev_login_enabled !== 'boolean') throw new Error('CONTRACT_ERROR: Anmeldemodi nicht ausdrücklich konfiguriert');
|
||||
// Only the canonical same-origin server entrypoint is allowed. No issuer,
|
||||
// return URL, query, fragment, credentials or externally supplied redirect.
|
||||
if (r.oidc_configured ? r.oidc_login_url !== '/auth/oidc/login' : r.oidc_login_url !== null) throw new Error('CONTRACT_ERROR: OIDC-Anmeldepfad ungültig');
|
||||
return { oidc_configured: r.oidc_configured, dev_login_enabled: r.dev_login_enabled, oidc_login_url: r.oidc_configured ? '/auth/oidc/login' : null };
|
||||
}
|
||||
export function tenant(value: unknown): Tenant { const r = record(value); return { tenant_id: text(r.tenant_id ?? r.id, 'tenant_id'), name: text(r.name, 'tenant.name') }; }
|
||||
export function session(value: unknown): Session {
|
||||
const r = record(value);
|
||||
const strings = (v: unknown): string[] | undefined => Array.isArray(v) && v.every(x => typeof x === 'string') ? v : undefined;
|
||||
const membership = { permissions: strings(r.permissions), roles: strings(r.roles) };
|
||||
// Both OIDC humans and dev/test principals use this DTO. Only the server's
|
||||
// explicit boolean marks a simulation; names/roles never imply that identity.
|
||||
if (typeof r.principal === 'string' && typeof r.testsimulation === 'boolean') {
|
||||
const id = text(r.principal, 'principal'), tenantId = text(r.tenant_id, 'tenant_id');
|
||||
return { principal: { id, display_name: id, simulated: r.testsimulation }, tenants: [{ tenant_id: tenantId, name: tenantId }], csrf_token: text(r.csrf_token, 'csrf_token'), ...membership };
|
||||
}
|
||||
const p = record(r.principal, 'principal');
|
||||
if (typeof p.simulated !== 'boolean' || !Array.isArray(r.tenants)) throw new Error('CONTRACT_ERROR: Sitzungsprofil unvollständig');
|
||||
return { principal: { id: text(p.id, 'principal.id'), display_name: text(p.display_name, 'principal.display_name'), simulated: p.simulated }, tenants: r.tenants.map(tenant), csrf_token: text(r.csrf_token, 'csrf_token'), ...membership };
|
||||
}
|
||||
export function page(value: unknown): Page {
|
||||
const r = record(value);
|
||||
if (!Array.isArray(r.items)) throw new Error('CONTRACT_ERROR: items fehlt');
|
||||
if (r.next_cursor !== null && typeof r.next_cursor !== 'string') throw new Error('CONTRACT_ERROR: next_cursor fehlt');
|
||||
return { items: r.items.map(v => record(v)), next_cursor: r.next_cursor, completeness: stringField(r, 'completeness'), truncated: r.truncated !== false, as_of: stringField(r, 'as_of') };
|
||||
}
|
||||
export class ApiError extends Error { constructor(public status: number, public code: string, message: string, public correlation: string) { super(`${code}: ${message}${correlation ? ` (Korrelation ${correlation})` : ''}`); } }
|
||||
export async function request(path: string, options: { body?: unknown; csrf?: string; signal?: AbortSignal } = {}): Promise<unknown> {
|
||||
if (!path.startsWith('/') || path.startsWith('//')) throw new Error('Nur gleiche Origin erlaubt');
|
||||
const changing = options.body !== undefined;
|
||||
const response = await fetch(path, { method: changing ? 'POST' : 'GET', credentials: 'same-origin', cache: 'no-store', signal: options.signal,
|
||||
headers: changing ? { 'Content-Type': 'application/json', ...(options.csrf ? { 'X-CSRF-Token': options.csrf } : {}) } : {}, body: changing ? JSON.stringify(options.body) : undefined });
|
||||
const raw: unknown = response.status === 204 ? {} : await response.json().catch(() => { throw new ApiError(response.status, 'HTTP_ERROR', 'keine JSON-Antwort', ''); });
|
||||
if (!response.ok) { const r = record(raw); throw new ApiError(response.status, stringField(r, 'code'), stringField(r, 'message'), typeof r.correlation_id === 'string' ? r.correlation_id : ''); }
|
||||
return raw;
|
||||
}
|
||||
export const tenantPath = (id: string, suffix = '') => `/api/v1/tenants/${encodeURIComponent(id)}${suffix}`;
|
||||
export const objectId = (r: RecordValue, kind: string) => text(r[`${kind}_id`] ?? r.id, `${kind}_id`);
|
||||
export const pretty = (v: unknown) => JSON.stringify(v, null, 2);
|
||||
|
||||
export const actions = ['run_script', 'refresh_inventory', 'query_logs', 'set_service_state', 'ensure_package', 'apply_updates', 'reboot', 'apt_native_acceptance'] as const;
|
||||
export type Action = typeof actions[number];
|
||||
export interface PlanInput { tenant_id: string; action: Action; targets: { asset_ids: string[] }; parameters: RecordValue; artifact_ids?: string[]; schedule: { not_before: string; start_before: string; offline_policy: 'wait_until_deadline' }; rollout: { max_parallel: number; halt_after_failures: number }; reason: string }
|
||||
export function validateInput(input: PlanInput): void {
|
||||
if (!input.targets.asset_ids.length || new Set(input.targets.asset_ids).size !== input.targets.asset_ids.length) throw new Error('Feste eindeutige Ziele erforderlich');
|
||||
if (!input.reason.trim()) throw new Error('Begründung erforderlich');
|
||||
const start = Date.parse(input.schedule.not_before), end = Date.parse(input.schedule.start_before);
|
||||
if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start || end <= Date.now()) throw new Error('Ungültige oder abgelaufene Frist');
|
||||
for (const n of [input.rollout.max_parallel, input.rollout.halt_after_failures, input.parameters.timeout_seconds, input.parameters.max_output_bytes]) if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 1) throw new Error('Limits müssen positive Ganzzahlen sein');
|
||||
if (input.action === 'run_script') {
|
||||
const variants = input.parameters.variants;
|
||||
if (!Array.isArray(variants) || !variants.length || !variants.every(v => {
|
||||
const variant = record(v), bytes = typeof variant.script_utf8 === 'string' ? new TextEncoder().encode(variant.script_utf8).length : 0;
|
||||
return bytes > 0 && bytes <= 32768 && !String(variant.script_utf8).includes('\0') && variant.os_family === 'linux' && variant.encoding === 'utf-8' && ['posix_sh', 'bash'].includes(String(variant.interpreter));
|
||||
})) throw new Error('Exakte Linux UTF-8 Skriptbytes und Interpreter erforderlich (max. 32 KiB)');
|
||||
}
|
||||
if (!['agent_service', 'root'].includes(String(input.parameters.execution_identity))) throw new Error('Explizite Ausführungsidentität erforderlich');
|
||||
const required = (key: string) => text(input.parameters[key], `parameters.${key}`);
|
||||
if (input.action === 'refresh_inventory') required('scope');
|
||||
if (input.action === 'query_logs') { required('unit'); const since = Date.parse(required('since')), until = Date.parse(required('until')); if (!Number.isFinite(since) || !Number.isFinite(until) || until <= since) throw new Error('Exaktes Log-Zeitfenster erforderlich'); if (typeof input.parameters.max_lines !== 'number' || !Number.isSafeInteger(input.parameters.max_lines) || input.parameters.max_lines < 1 || input.parameters.max_lines > 1000) throw new Error('Loglimit muss 1–1000 sein'); }
|
||||
if (input.action === 'set_service_state') { required('unit'); if (!['running', 'stopped', 'restarted'].includes(required('state'))) throw new Error('Ungültiger Dienstzustand'); }
|
||||
if (input.action === 'ensure_package') { for (const key of ['provider', 'recipe_version', 'package', 'version', 'architecture', 'installation_context']) required(key); }
|
||||
if (input.action === 'apply_updates') { required('provider'); if (!Array.isArray(input.parameters.packages) || !input.parameters.packages.length || !input.parameters.packages.every(v => typeof v === 'string' && v.length > 0)) throw new Error('Feste Updatepakete erforderlich'); if (input.parameters.reboot_policy !== 'never') throw new Error('Kein impliziter Reboot; eigenen festen Plan erstellen'); }
|
||||
if (input.action === 'reboot') { required('reason'); required('dependency_group'); const n = input.parameters.reconnect_timeout_seconds; if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 60 || n > 3600) throw new Error('Reboot-Wiederanmeldefrist muss 60–3600 s sein'); }
|
||||
}
|
||||
/** These are immutable target definitions, never evidence of executable jobs. */
|
||||
export function planTargetPreviews(plan: RecordValue): unknown[] | null {
|
||||
if (Array.isArray(plan.resolved_targets) && plan.resolved_targets.some(value =>
|
||||
value !== null && typeof value === 'object' && !Array.isArray(value) && ('payload' in value || 'job_payload_hash' in value))) return plan.resolved_targets;
|
||||
if (plan.payloads !== undefined) return Array.isArray(plan.payloads) ? plan.payloads : null;
|
||||
// Legacy DTO name: jobs here contains previews, not pre-approval execution rows.
|
||||
return Array.isArray(plan.jobs) ? plan.jobs : null;
|
||||
}
|
||||
export function approvalBlockers(plan: RecordValue): string[] {
|
||||
const errors: string[] = [];
|
||||
for (const key of ['plan_id', 'plan_hash', 'expires_at']) if (typeof plan[key] !== 'string' || !plan[key]) errors.push(`${key} fehlt`);
|
||||
if (!Number.isFinite(Date.parse(String(plan.expires_at))) || Date.parse(String(plan.expires_at)) <= Date.now()) errors.push('Planfrist ungültig/abgelaufen');
|
||||
if (!Array.isArray(plan.resolved_targets) || !plan.resolved_targets.length) errors.push('Vollständige feste Zielmenge fehlt');
|
||||
if (!Array.isArray(plan.excluded_targets) || plan.excluded_targets.length) errors.push('Ausgeschlossene Ziele oder unbekannte Zielabdeckung');
|
||||
const isRecord = (value: unknown): value is RecordValue => value !== null && typeof value === 'object' && !Array.isArray(value);
|
||||
const targetIds: string[] = [];
|
||||
if (Array.isArray(plan.resolved_targets)) for (const value of plan.resolved_targets) {
|
||||
const id = typeof value === 'string' ? value : isRecord(value) ? value.asset_id : undefined;
|
||||
if (typeof id !== 'string' || !id.trim()) errors.push('Ziel: asset_id fehlt');
|
||||
else targetIds.push(id);
|
||||
}
|
||||
if (new Set(targetIds).size !== targetIds.length) errors.push('Doppelte asset_id in fester Zielmenge');
|
||||
const previews = planTargetPreviews(plan), previewTargets = new Set<string>();
|
||||
if (!previews?.length) errors.push('Unveränderliche Zielpreviews fehlen');
|
||||
else for (const value of previews) {
|
||||
if (!isRecord(value)) { errors.push('Ungültige Zielpreview'); continue; }
|
||||
const payload = value.payload;
|
||||
const id = value.asset_id ?? (isRecord(payload) ? payload.asset_id : undefined);
|
||||
if (typeof id !== 'string' || !id.trim()) errors.push('Zielpreview: asset_id fehlt');
|
||||
else {
|
||||
if (previewTargets.has(id)) errors.push('Doppelte asset_id in Zielpreviews');
|
||||
previewTargets.add(id);
|
||||
if (isRecord(payload) && payload.asset_id !== undefined && payload.asset_id !== id) errors.push('Zielpreview und Payload widersprechen sich bei asset_id');
|
||||
}
|
||||
if (typeof value.job_payload_hash !== 'string' || !value.job_payload_hash.trim()) errors.push('Zielpreview: job_payload_hash fehlt');
|
||||
if (!isRecord(payload) || !Object.keys(payload).length) errors.push('Exakter Zielpayload fehlt');
|
||||
}
|
||||
if (targetIds.some(id => !previewTargets.has(id)) || [...previewTargets].some(id => !targetIds.includes(id))) errors.push('Feste Ziele und Zielpreviews stimmen nicht vollständig überein');
|
||||
if (plan.plan_payload_bytes === undefined && plan.plan_payload === undefined) errors.push('Gespeicherter Planpayload fehlt');
|
||||
return errors;
|
||||
}
|
||||
Reference in New Issue
Block a user