@ours.network/fleet 1.0.5 → 1.1.0-nightly.10

package/dist/web/fleet-config-service.js

@@ -1,240 +1,441 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { chmodSync, existsSync, lstatSync, readFileSync, rmSync, } from 'node:fs';
-import { basename, dirname, join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { chmodSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, } from 'node:fs';
+import { basename, dirname, extname, join } from 'node:path';
+import { parse, stringify } from 'yaml';
 import { replaceFileAtomically, withFileLock } from '../atomic-file.js';
-import { loadConfig } from '../config.js';
+import { loadConfig, ROLE_NAME_RE, splitRootFor } from '../config.js';
 import { parseFleetDocument } from '../config-yaml.js';
 import { defaultConfigPath } from '../paths.js';
 import { FleetError } from '../application/errors.js';
 import { redactSourceSecrets, renderModelOntoSource } from './yaml-document-edit.js';
+import { isSensitiveConfigKey } from '../sensitive-config.js';
 export const REDACTED_ENV_VALUE = '__OURS_FLEET_SECRET_REDACTED__';
 const MAX_CONFIG_BYTES = 256 * 1024;
 const DIFF_CONTEXT_LINES = 3;
+const KINDS = ['agents', 'roles', 'brains', 'room_templates'];
 const emptyReport = () => ({ ok: true, checks: [] });
 export class FleetConfigService {
     path;
     preflight;
+    beforeMutation;
     constructor(options = {}) {
         this.path = options.configPath ?? defaultConfigPath();
         this.preflight = options.preflight ?? (async () => emptyReport());
+        this.beforeMutation = options.beforeMutation;
     }
     read() {
-        const source = this.readSource();
-        const parsed = parseFleetDocument(this.path, source, 'strict').value;
-        const redacted = redactModel(parsed);
+        const sources = readSources(this.path);
+        try {
+            loadConfig(this.path, { yamlMode: 'strict' });
+        }
+        catch (error) {
+            throw safeError(error, sourceSensitiveValues(sources));
+        }
+        const raw = modelFrom(sources);
+        const redacted = redactModel(raw);
         return {
-            path: basename(this.path), exists: existsSync(this.path),
-            firstRun: !existsSync(this.path), revision: digest(source),
-            model: redacted.model, redactions: redacted.paths,
+            path: basename(this.path), exists: true, firstRun: false,
+            revision: revision(sources), model: redacted.model, redactions: redacted.paths,
         };
     }
-    async preview(baseRevision, model) {
-        const currentSource = this.readSource();
-        this.assertRevision(baseRevision, currentSource);
-        const current = parseFleetDocument(this.path, currentSource, 'strict').value;
-        const restored = restoreRedactions(assertModel(model), current);
-        const nextSource = render(currentSource, restored);
-        const candidate = this.validateCandidate(nextSource);
-        const redactedNext = redactModel(restored);
-        const preflight = await this.preflight(candidate.path).finally(candidate.remove);
-        return {
-            valid: true, revision: digest(currentSource), normalizedModel: redactedNext.model,
-            diff: sourceDiff(currentSource, nextSource),
-            redactions: redactedNext.paths,
-            impact: restartImpact(current, restored), preflight,
-        };
+    async preview(baseRevision, input) {
+        const current = readSources(this.path);
+        assertRevision(baseRevision, current);
+        const currentModel = modelFrom(current);
+        const next = restoreRedactions(assertModel(input), currentModel, new Set(redactModel(currentModel).paths));
+        const proposal = renderProposal(current, next);
+        const staged = stageProposal(this.path, current, proposal);
+        let preflight;
+        try {
+            loadConfig(staged.manifest, { yamlMode: 'strict' });
+            preflight = await this.preflight(staged.manifest);
+        }
+        catch (error) {
+            throw safeError(error, [...sensitiveValues(next), ...sourceSensitiveValues(current)]);
+        }
+        finally {
+            staged.remove();
+        }
+        const redacted = redactModel(next);
+        return result(current, currentModel, next, proposal, redacted, preflight);
     }
-    async write(baseRevision, model) {
-        return withFileLock(`${this.path}.web-edit.lock`, async () => {
-            const currentSource = this.readSource();
-            this.assertRevision(baseRevision, currentSource);
-            const current = parseFleetDocument(this.path, currentSource, 'strict').value;
-            const restored = restoreRedactions(assertModel(model), current);
-            const nextSource = render(currentSource, restored);
-            const candidate = this.validateCandidate(nextSource);
-            const preflight = await this.preflight(candidate.path).finally(candidate.remove);
-            // The lock coordinates trusted web/agent writers. An operator's editor does
-            // not take it, so re-check immediately before replacement as well.
-            this.assertRevision(baseRevision, this.readSource());
-            const redactedNext = redactModel(restored);
-            let backup;
-            if (existsSync(this.path)) {
-                backup = `${basename(this.path)}.backup-${new Date().toISOString().replace(/[:.]/g, '-')}-${randomUUID().slice(0, 8)}`;
-                replaceFileAtomically(join(dirname(this.path), backup), currentSource, 0o600);
+    async write(baseRevision, input) {
+        return withFileLock(`${splitRootFor(this.path)}.web-edit.lock`, async () => {
+            const current = readSources(this.path);
+            assertRevision(baseRevision, current);
+            const currentModel = modelFrom(current);
+            const next = restoreRedactions(assertModel(input), currentModel, new Set(redactModel(currentModel).paths));
+            const proposal = renderProposal(current, next);
+            const changed = changedDocuments(current, proposal);
+            const staged = stageProposal(this.path, current, proposal);
+            let preflight;
+            try {
+                loadConfig(staged.manifest, { yamlMode: 'strict' });
+                preflight = await this.preflight(staged.manifest);
+            }
+            catch (error) {
+                throw safeError(error, [...sensitiveValues(next), ...sourceSensitiveValues(current)]);
+            }
+            finally {
+                staged.remove();
+            }
+            assertRevision(baseRevision, readSources(this.path));
+            if (!changed.length) {
+                const redacted = redactModel(next);
+                return { ...result(current, currentModel, next, proposal, redacted, preflight),
+                    saved: true, newRevision: baseRevision };
+            }
+            recheckCollisions(current, proposal, changed);
+            const backupRoot = mkdtempSync(join(dirname(this.path), '.fleet-web-backup-'));
+            chmodSync(backupRoot, 0o700);
+            const backupFiles = join(backupRoot, 'files');
+            mkdirSync(backupFiles, { recursive: true, mode: 0o700 });
+            for (const rel of changed)
+                if (current.documents.has(rel)) {
+                    const target = join(backupFiles, rel);
+                    mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
+                    replaceFileAtomically(target, current.documents.get(rel), 0o600);
+                }
+            try {
+                changed.forEach((rel, index) => {
+                    this.beforeMutation?.(rel, index);
+                    const target = absoluteFor(this.path, rel);
+                    const contents = proposal.get(rel);
+                    if (contents === undefined)
+                        rmSync(target, { force: true });
+                    else {
+                        assertWritableTarget(target, current.documents.has(rel));
+                        replaceFileAtomically(target, contents, 0o600);
+                        chmodSync(target, 0o600);
+                    }
+                });
+            }
+            catch (error) {
+                try {
+                    for (const rel of changed) {
+                        const target = absoluteFor(this.path, rel);
+                        const old = current.documents.get(rel);
+                        if (old === undefined)
+                            rmSync(target, { force: true });
+                        else
+                            replaceFileAtomically(target, old, 0o600);
+                    }
+                }
+                catch (rollback) {
+                    throw new FleetError('internal', `configuration recovery failed; restore from ${backupRoot}`, { details: { rollback: rollback instanceof Error ? rollback.message : String(rollback) } });
+                }
+                throw safeError(error, sensitiveValues(next));
             }
-            replaceFileAtomically(this.path, nextSource, 0o600);
-            chmodSync(this.path, 0o600);
-            return {
-                saved: true, valid: true, revision: digest(currentSource), newRevision: digest(nextSource),
-                normalizedModel: redactedNext.model,
-                diff: sourceDiff(currentSource, nextSource),
-                redactions: redactedNext.paths, impact: restartImpact(current, restored), preflight,
-                backup,
-            };
+            const final = readSources(this.path);
+            const redacted = redactModel(next);
+            return { ...result(current, currentModel, next, proposal, redacted, preflight),
+                saved: true, newRevision: revision(final), backup: backupRoot };
         });
     }
-    readSource() {
-        if (!existsSync(this.path))
-            return 'roles: {}\n';
-        const stat = lstatSync(this.path);
-        const uid = process.getuid?.();
-        if (!stat.isFile() || stat.isSymbolicLink())
-            throw new FleetError('invalid_request', 'fleet configuration must be a regular non-symlink file');
-        if (stat.size > MAX_CONFIG_BYTES)
-            throw new FleetError('invalid_request', `fleet configuration exceeds ${MAX_CONFIG_BYTES} bytes`);
-        if (uid !== undefined && stat.uid !== uid)
-            throw new FleetError('forbidden', 'fleet configuration is not owned by the current user');
-        return readFileSync(this.path, 'utf8');
-    }
-    assertRevision(expected, source) {
-        if (!expected || expected !== digest(source))
-            throw new FleetError('stale_state', 'fleet.yaml changed since it was opened; reload before saving');
-    }
-    validateCandidate(source) {
-        if (Buffer.byteLength(source) > MAX_CONFIG_BYTES)
-            throw new FleetError('invalid_request', `fleet configuration exceeds ${MAX_CONFIG_BYTES} bytes`);
-        const candidate = join(dirname(this.path), `.${basename(this.path)}.preview-${process.pid}-${randomUUID()}.yaml`);
-        replaceFileAtomically(candidate, source, 0o600);
-        try {
-            loadConfig(candidate, { yamlMode: 'strict' });
+}
+function trustedFile(path) {
+    let stat;
+    try {
+        stat = lstatSync(path);
+    }
+    catch {
+        throw new FleetError('invalid_request', `missing configuration source ${path}`);
+    }
+    const uid = process.getuid?.();
+    if (!stat.isFile() || stat.isSymbolicLink())
+        throw new FleetError('invalid_request', `${path} must be a regular non-symlink file`);
+    if (uid !== undefined && stat.uid !== uid)
+        throw new FleetError('forbidden', `${path} is not owned by the current user`);
+    if ((stat.mode & 0o022) !== 0)
+        throw new FleetError('forbidden', `${path} is group/world writable`);
+    if (stat.size > MAX_CONFIG_BYTES)
+        throw new FleetError('invalid_request', `${path} exceeds ${MAX_CONFIG_BYTES} bytes`);
+    return readFileSync(path, 'utf8');
+}
+function trustedDirectory(path) {
+    const stat = lstatSync(path);
+    const uid = process.getuid?.();
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new FleetError('invalid_request', `${path} must be a non-symlink directory`);
+    if (uid !== undefined && stat.uid !== uid)
+        throw new FleetError('forbidden', `${path} is not owned by the current user`);
+    if ((stat.mode & 0o022) !== 0)
+        throw new FleetError('forbidden', `${path} is group/world writable`);
+}
+function readSources(manifest) {
+    const documents = new Map();
+    documents.set(basename(manifest), trustedFile(manifest));
+    const root = splitRootFor(manifest);
+    trustedDirectory(root);
+    for (const kind of KINDS) {
+        const dir = join(root, kind);
+        if (!existsSync(dir)) {
+            if (kind === 'agents')
+                throw new FleetError('invalid_request', `required Agent root missing: ${dir}`);
+            continue;
         }
-        catch (error) {
-            rmSync(candidate, { force: true });
-            throw new FleetError('invalid_request', error.message);
+        trustedDirectory(dir);
+        for (const name of readdirSync(dir).sort()) {
+            if ((kind === 'agents' || kind === 'room_templates')
+                && !['.yaml', '.yml'].includes(extname(name).toLowerCase()))
+                continue;
+            documents.set(join(kind, name), trustedFile(join(dir, name)));
         }
-        return { path: candidate, remove: () => rmSync(candidate, { force: true }) };
     }
+    return { manifest, root, documents };
+}
+function modelFrom(sources) {
+    const manifestKey = basename(sources.manifest);
+    const manifest = parseFleetDocument(sources.manifest, sources.documents.get(manifestKey), 'strict').value;
+    const agents = {};
+    for (const [rel, source] of sources.documents)
+        if (rel.startsWith(`agents/`)) {
+            const id = basename(rel, extname(rel));
+            agents[id] = parseFleetDocument(absoluteFor(sources.manifest, rel), source, 'strict').value;
+        }
+    return { manifest, agents };
 }
 function assertModel(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
-        throw new FleetError('invalid_request', 'model must be a JSON object');
-    return structuredClone(value);
-}
-/**
- * Apply the edited model onto the user's own document rather than re-serializing
- * it, so comments, key order and formatting outside the edit survive the save.
- */
-function render(currentSource, model) {
+        throw new FleetError('invalid_request', 'model must be an object');
+    const input = value;
+    if (Object.keys(input).sort().join(',') !== 'agents,manifest')
+        throw new FleetError('invalid_request', 'model allows exactly manifest and agents');
+    for (const key of ['manifest', 'agents'])
+        if (!input[key] || typeof input[key] !== 'object' || Array.isArray(input[key]))
+            throw new FleetError('invalid_request', `${key} must be an object`);
+    for (const [id, doc] of Object.entries(input.agents)) {
+        if (!ROLE_NAME_RE.test(id))
+            throw new FleetError('invalid_request', `invalid Agent ID '${id}'`);
+        if (!doc || typeof doc !== 'object' || Array.isArray(doc))
+            throw new FleetError('invalid_request', `Agent '${id}' must be an object`);
+    }
+    return structuredClone(input);
+}
+function renderProposal(current, model) {
+    const next = new Map();
+    const manifestRel = basename(current.manifest);
+    next.set(manifestRel, render(current.documents.get(manifestRel), model.manifest));
+    for (const [id, doc] of Object.entries(model.agents).sort(([a], [b]) => a.localeCompare(b))) {
+        const oldRel = [...current.documents.keys()].find(rel => rel.startsWith('agents/')
+            && basename(rel, extname(rel)) === id);
+        next.set(oldRel ?? join('agents', `${id}.yaml`), oldRel
+            ? render(current.documents.get(oldRel), doc) : stringify(doc));
+    }
+    for (const [rel, source] of current.documents)
+        if (rel.startsWith('roles/') || rel.startsWith('brains/') || rel.startsWith('room_templates/'))
+            next.set(rel, source);
+    return next;
+}
+function render(source, model) {
     try {
-        return renderModelOntoSource(currentSource, model);
+        return renderModelOntoSource(source, model);
     }
     catch (error) {
-        throw new FleetError('invalid_request', error.message);
+        throw safeError(error);
+    }
+}
+function stageProposal(manifest, current, proposal) {
+    const dir = mkdtempSync(join(dirname(manifest), '.fleet-web-preview-'));
+    chmodSync(dir, 0o700);
+    const stagedManifest = join(dir, basename(manifest));
+    const stagedRoot = splitRootFor(stagedManifest);
+    mkdirSync(stagedRoot, { recursive: true, mode: 0o700 });
+    mkdirSync(join(stagedRoot, 'agents'), { mode: 0o700 });
+    for (const [rel, source] of proposal) {
+        const target = rel === basename(manifest) ? stagedManifest : join(stagedRoot, rel);
+        mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
+        replaceFileAtomically(target, source, 0o600);
     }
+    return { manifest: stagedManifest, remove: () => rmSync(dir, { recursive: true, force: true }) };
 }
-function digest(source) {
-    return createHash('sha256').update(source).digest('hex');
+function changedDocuments(current, proposal) {
+    return [...new Set([...current.documents.keys(), ...proposal.keys()])]
+        .filter(rel => current.documents.get(rel) !== proposal.get(rel)).sort();
 }
-function envMaps(model) {
-    const maps = [];
-    const add = (value, path) => {
-        if (value && typeof value === 'object' && !Array.isArray(value))
-            maps.push({ path, map: value });
-    };
-    add(model.defaults?.env, 'defaults.env');
-    const roles = model.roles;
-    if (roles && typeof roles === 'object' && !Array.isArray(roles))
-        for (const [name, raw] of Object.entries(roles))
-            add(raw?.env, `roles.${name}.env`);
-    return maps;
+function recheckCollisions(current, proposal, changed) {
+    for (const rel of changed) {
+        const target = absoluteFor(current.manifest, rel);
+        const existed = current.documents.has(rel);
+        if (!existed && proposal.has(rel) && existsSync(target))
+            throw new FleetError('stale_state', `configuration collision at ${rel}`);
+        if (existed)
+            trustedFile(target);
+    }
+}
+function assertWritableTarget(path, existed) {
+    if (!existsSync(path)) {
+        if (existed)
+            throw new FleetError('stale_state', `${path} disappeared`);
+        return;
+    }
+    trustedFile(path);
+}
+function absoluteFor(manifest, rel) {
+    return rel === basename(manifest) ? manifest : join(splitRootFor(manifest), rel);
+}
+function revision(sources) {
+    const hash = createHash('sha256');
+    for (const [rel, bytes] of [...sources.documents].sort(([a], [b]) => a.localeCompare(b)))
+        hash.update(`${Buffer.byteLength(rel)}:${rel}:${Buffer.byteLength(bytes)}:`).update(bytes);
+    return hash.digest('hex');
+}
+function assertRevision(expected, sources) {
+    if (!expected || expected !== revision(sources))
+        throw new FleetError('stale_state', 'configuration sources changed since opened; reload before saving');
+}
+function sensitive(key, inEnv) {
+    return inEnv || isSensitiveConfigKey(key);
 }
 function redactModel(input) {
     const model = structuredClone(input);
     const paths = [];
-    const secretVars = new Set();
-    for (const item of envMaps(model))
-        for (const [key, value] of Object.entries(item.map)) {
-            if (typeof value === 'string')
-                for (const match of value.matchAll(/\$\{(\w+)\}/g))
-                    secretVars.add(match[1]);
-            item.map[key] = REDACTED_ENV_VALUE;
-            paths.push(`${item.path}.${key}`);
+    const walk = (value, path, inEnv = false) => {
+        if (Array.isArray(value)) {
+            value.forEach((item, i) => {
+                if (inEnv && item !== null && typeof item !== 'object') {
+                    value[i] = REDACTED_ENV_VALUE;
+                    paths.push(`${path}/${i}`);
+                }
+                else
+                    walk(item, `${path}/${i}`, inEnv);
+            });
+            return;
         }
-    const vars = model.vars;
-    if (vars && typeof vars === 'object' && !Array.isArray(vars))
-        for (const key of secretVars)
-            if (key in vars) {
-                vars[key] = REDACTED_ENV_VALUE;
-                paths.push(`vars.${key}`);
+        if (!value || typeof value !== 'object')
+            return;
+        for (const [key, child] of Object.entries(value)) {
+            const next = `${path}/${key}`;
+            if (sensitive(key, inEnv) && child !== null && typeof child !== 'object') {
+                value[key] = REDACTED_ENV_VALUE;
+                paths.push(next);
             }
+            else
+                walk(child, next, inEnv || key === 'env' || sensitive(key, false));
+        }
+    };
+    walk(model, '');
     return { model, paths: paths.sort() };
 }
-function restoreRedactions(next, current) {
-    const oldByPath = new Map(envMaps(current).map(item => [item.path, item.map]));
-    for (const item of envMaps(next))
-        for (const [key, value] of Object.entries(item.map)) {
-            if (value !== REDACTED_ENV_VALUE)
-                continue;
-            const previous = oldByPath.get(item.path)?.[key];
-            if (previous === undefined)
-                throw new FleetError('invalid_request', `${item.path}.${key} uses a redaction marker with no prior value`);
-            item.map[key] = previous;
+function restoreRedactions(next, old, allowed) {
+    const walk = (value, previous, path) => {
+        if (Array.isArray(value)) {
+            value.forEach((item, i) => {
+                const prior = Array.isArray(previous) ? previous[i] : undefined;
+                if (item === REDACTED_ENV_VALUE) {
+                    if (!allowed.has(`${path}/${i}`) || prior === undefined)
+                        throw new FleetError('invalid_request', `${path}/${i} has no prior redacted value`);
+                    value[i] = structuredClone(prior);
+                }
+                else
+                    walk(item, prior, `${path}/${i}`);
+            });
+            return;
         }
-    const nextVars = next.vars;
-    const oldVars = current.vars;
-    if (nextVars)
-        for (const [key, value] of Object.entries(nextVars)) {
-            if (value !== REDACTED_ENV_VALUE)
-                continue;
-            if (!oldVars || oldVars[key] === undefined)
-                throw new FleetError('invalid_request', `vars.${key} uses a redaction marker with no prior value`);
-            nextVars[key] = oldVars[key];
+        if (!value || typeof value !== 'object')
+            return;
+        for (const [key, child] of Object.entries(value)) {
+            const prior = previous && typeof previous === 'object' && !Array.isArray(previous)
+                ? previous[key] : undefined;
+            if (child === REDACTED_ENV_VALUE) {
+                if (!allowed.has(`${path}/${key}`) || prior === undefined)
+                    throw new FleetError('invalid_request', `${path}/${key} has no prior redacted value`);
+                value[key] = structuredClone(prior);
+            }
+            else
+                walk(child, prior, `${path}/${key}`);
         }
+    };
+    walk(next, old, '');
     return next;
 }
-/**
- * Unified-style diff of the real file text with env secrets masked. Common
- * leading/trailing lines are trimmed, so a surgical edit reviews as a small
- * hunk instead of the whole configuration twice.
- */
-function sourceDiff(beforeSource, afterSource) {
-    const before = splitLines(redactSourceSecrets(beforeSource, REDACTED_ENV_VALUE));
-    const after = splitLines(redactSourceSecrets(afterSource, REDACTED_ENV_VALUE));
+function maskSource(source, secrets) {
+    let masked = redactSourceSecrets(source, REDACTED_ENV_VALUE);
+    for (const secret of secrets.sort((a, b) => b.length - a.length))
+        if (secret)
+            masked = masked.split(secret).join(REDACTED_ENV_VALUE);
+    return masked;
+}
+function sourceDiff(before, after, label, secrets) {
+    const left = splitLines(maskSource(before, secrets));
+    const right = splitLines(maskSource(after, secrets));
     let head = 0;
-    while (head < before.length && head < after.length && before[head] === after[head])
-        head += 1;
+    while (head < left.length && head < right.length && left[head] === right[head])
+        head++;
     let tail = 0;
-    while (tail < before.length - head && tail < after.length - head
-        && before[before.length - 1 - tail] === after[after.length - 1 - tail])
-        tail += 1;
-    if (head === before.length && head === after.length)
+    while (tail < left.length - head && tail < right.length - head
+        && left[left.length - 1 - tail] === right[right.length - 1 - tail])
+        tail++;
+    if (head === left.length && head === right.length)
         return '';
     const start = Math.max(0, head - DIFF_CONTEXT_LINES);
     const trailing = Math.min(DIFF_CONTEXT_LINES, tail);
-    const beforeSpan = before.length - tail + trailing - start;
-    const afterSpan = after.length - tail + trailing - start;
-    return [
-        '--- fleet.yaml (current)', '+++ fleet.yaml (proposed)',
-        `@@ -${start + 1},${beforeSpan} +${start + 1},${afterSpan} @@`,
-        ...before.slice(start, head).map(line => ` ${line}`),
-        ...before.slice(head, before.length - tail).map(line => `-${line}`),
-        ...after.slice(head, after.length - tail).map(line => `+${line}`),
-        ...before.slice(before.length - tail, before.length - tail + trailing).map(line => ` ${line}`),
-        '',
-    ].join('\n');
-}
-function splitLines(source) {
-    return source.replace(/\n$/, '').split('\n');
-}
-function objectKeys(value) {
-    return value && typeof value === 'object' && !Array.isArray(value) ? Object.keys(value) : [];
+    return [`--- ${label} (current)`, `+++ ${label} (proposed)`,
+        `@@ -${start + 1},${left.length - tail + trailing - start} +${start + 1},${right.length - tail + trailing - start} @@`,
+        ...left.slice(start, head).map(x => ` ${x}`), ...left.slice(head, left.length - tail).map(x => `-${x}`),
+        ...right.slice(head, right.length - tail).map(x => `+${x}`),
+        ...left.slice(left.length - tail, left.length - tail + trailing).map(x => ` ${x}`), ''].join('\n');
+}
+function proposalDiff(current, proposal) {
+    const secrets = sensitiveValues(modelFrom(current));
+    try {
+        secrets.push(...sensitiveValues(modelFrom({ ...current, documents: proposal })));
+    }
+    catch { /* validation reports later */ }
+    return [...new Set([...current.documents.keys(), ...proposal.keys()])].sort().map(rel => sourceDiff(current.documents.get(rel) ?? '', proposal.get(rel) ?? '', rel, secrets)).filter(Boolean).join('\n');
 }
+function splitLines(source) { return source.replace(/\n$/, '').split('\n'); }
 function restartImpact(before, after) {
-    const changed = (key) => JSON.stringify(before[key]) !== JSON.stringify(after[key]);
-    const beforeRoles = (before.roles ?? {});
-    const afterRoles = (after.roles ?? {});
-    const roles = [...new Set([...objectKeys(beforeRoles), ...objectKeys(afterRoles)])]
-        .filter(name => JSON.stringify(beforeRoles[name]) !== JSON.stringify(afterRoles[name])).sort();
-    if (changed('defaults'))
-        roles.splice(0, roles.length, ...objectKeys(afterRoles).sort());
-    const watchdogScheduler = changed('watchdogs');
-    const scheduledLoops = changed('loops');
-    const required = roles.length > 0 || watchdogScheduler || scheduledLoops || changed('vars');
-    const parts = [roles.length ? `${roles.length} role${roles.length === 1 ? '' : 's'}` : '',
-        watchdogScheduler ? 'watchdog scheduler' : '', scheduledLoops ? 'scheduled loops' : ''].filter(Boolean);
-    return {
-        required, roles, watchdogScheduler, scheduledLoops,
-        summary: required ? `Save only writes configuration; apply/restart ${parts.join(', ') || 'affected roles'} separately.`
-            : 'No running process needs a restart.',
+    const roles = [...new Set([...Object.keys(before.agents), ...Object.keys(after.agents)])]
+        .filter(id => JSON.stringify(before.agents[id]) !== JSON.stringify(after.agents[id])).sort();
+    const watchdogScheduler = JSON.stringify(before.manifest.watchdogs) !== JSON.stringify(after.manifest.watchdogs);
+    const scheduledLoops = JSON.stringify(before.manifest.loops) !== JSON.stringify(after.manifest.loops);
+    const required = roles.length > 0 || watchdogScheduler || scheduledLoops;
+    return { required, roles, watchdogScheduler, scheduledLoops,
+        summary: required ? 'Save only writes configuration; apply/restart affected roles separately.' : 'No running process needs a restart.' };
+}
+function result(current, before, after, proposal, redacted, preflight) {
+    return { valid: true, revision: revision(current), normalizedModel: redacted.model,
+        diff: proposalDiff(current, proposal), redactions: redacted.paths,
+        impact: restartImpact(before, after), preflight };
+}
+function sensitiveValues(model) {
+    const values = [];
+    const walk = (value, inSensitive = false) => {
+        if (Array.isArray(value)) {
+            for (const item of value)
+                walk(item, inSensitive);
+            return;
+        }
+        if (!value || typeof value !== 'object') {
+            if (inSensitive && typeof value === 'string' && value !== REDACTED_ENV_VALUE)
+                values.push(value);
+            return;
+        }
+        for (const [key, child] of Object.entries(value))
+            walk(child, inSensitive || key === 'env' || sensitive(key, false));
     };
+    walk(model);
+    return [...new Set(values)];
+}
+function sourceSensitiveValues(sources) {
+    const values = [];
+    for (const [rel, source] of sources.documents) {
+        if (!['.yaml', '.yml'].includes(extname(rel).toLowerCase()))
+            continue;
+        try {
+            const parsed = parse(source);
+            values.push(...sensitiveValues({ manifest: {}, agents: { source: parsed } }));
+        }
+        catch { /* the authoritative parser reports malformed YAML */ }
+    }
+    return [...new Set(values)];
+}
+function safeError(error, secrets = []) {
+    let message = error instanceof Error ? error.message : String(error);
+    for (const secret of secrets.sort((a, b) => b.length - a.length))
+        if (secret)
+            message = message.split(secret).join('[redacted]');
+    message = message.replace(/[^\s:]+(?:secret|token|password)[^\s:]*/gi, '[redacted]');
+    return new FleetError(error instanceof FleetError ? error.code : 'invalid_request', message);
 }