@b00dea/cockpit 0.0.0-stage → 0.1.1

package/dist/environment/executable.js

@@ -0,0 +1,190 @@
+import { createHash } from 'node:crypto';
+import { constants } from 'node:fs';
+import { lstat, open, realpath } from 'node:fs/promises';
+import { basename, delimiter, isAbsolute, join, normalize, resolve } from 'node:path';
+import { errorCause } from './contract.js';
+import { fileFingerprint, recordVerifiedDigest, verifiedDigest } from '../environment-exec/verified-digest.js';
+import { exactKeys } from '../exact-keys.js';
+// A guard runs inside the agent's hook with an environment the agent controls, so the tools it
+// observes with are found on this fixed search path rather than the inherited PATH.
+export const GUARD_EXECUTABLE_SEARCH_PATH = '/usr/bin:/bin:/usr/local/bin:/opt/homebrew/bin';
+const SHA256 = /^[a-f0-9]{64}$/;
+export function resolvedExecutable(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)
+        || !exactKeys(value, ['canonicalPath', 'invocationPath', 'sha256', 'executionMode']))
+        return undefined;
+    const { canonicalPath, invocationPath, sha256, executionMode } = value;
+    return typeof canonicalPath === 'string' && isAbsolute(canonicalPath) && normalize(canonicalPath) === canonicalPath
+        && !canonicalPath.includes('\0') && typeof invocationPath === 'string' && isAbsolute(invocationPath)
+        && normalize(invocationPath) === invocationPath && !invocationPath.includes('\0')
+        && typeof sha256 === 'string' && SHA256.test(sha256)
+        && executionMode === 'verified-path'
+        ? { canonicalPath, invocationPath, sha256, executionMode }
+        : undefined;
+}
+export function isResolvedExecutable(value) {
+    return resolvedExecutable(value) !== undefined;
+}
+export function resolvedDockerExecutable(value) {
+    const executable = resolvedExecutable(value);
+    return executable !== undefined && basename(executable.invocationPath) === 'docker' ? executable : undefined;
+}
+export function isResolvedDockerExecutable(value) {
+    return resolvedDockerExecutable(value) !== undefined;
+}
+export function resolvedGitExecutable(value) {
+    const executable = resolvedExecutable(value);
+    return executable !== undefined && basename(executable.invocationPath) === 'git' ? executable : undefined;
+}
+export function isResolvedGitExecutable(value) {
+    return resolvedGitExecutable(value) !== undefined;
+}
+const EXECUTABLE_BYTE_LIMIT = 536_870_912;
+const PATH_ENTRY_LIMIT = 256;
+function searchPath(env) {
+    try {
+        return { kind: 'selected', path: env.PATH };
+    }
+    catch { /* A throwing PATH getter means the environment is unreadable; the caller reports it as unavailable. */
+        return { kind: 'unreadable' };
+    }
+}
+function unavailable(reason) {
+    return { state: 'unavailable', reason };
+}
+async function digestRegularFile(path) {
+    let file;
+    try {
+        const before = await lstat(path);
+        if (before.isSymbolicLink() || !before.isFile() || before.size > EXECUTABLE_BYTE_LIMIT || (before.mode & 0o111) === 0)
+            return undefined;
+        file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+        const opened = await file.stat();
+        if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino || opened.size > EXECUTABLE_BYTE_LIMIT)
+            return undefined;
+        const fingerprint = fileFingerprint(path, opened);
+        const remembered = verifiedDigest(fingerprint);
+        if (remembered !== undefined)
+            return fileFingerprint(path, await lstat(path)) === fingerprint ? remembered : undefined;
+        const hash = createHash('sha256');
+        const chunk = Buffer.allocUnsafe(1_048_576);
+        let total = 0;
+        while (true) {
+            const { bytesRead } = await file.read(chunk, 0, Math.min(chunk.byteLength, EXECUTABLE_BYTE_LIMIT - total + 1), null);
+            if (bytesRead === 0)
+                break;
+            total += bytesRead;
+            if (total > EXECUTABLE_BYTE_LIMIT)
+                return undefined;
+            hash.update(chunk.subarray(0, bytesRead));
+        }
+        const after = await file.stat();
+        const linked = await lstat(path);
+        const sha256 = total === opened.size && after.size === opened.size && after.mtimeMs === opened.mtimeMs
+            && linked.dev === opened.dev && linked.ino === opened.ino && linked.size === opened.size && linked.mtimeMs === opened.mtimeMs
+            ? hash.digest('hex')
+            : undefined;
+        if (sha256 !== undefined && fileFingerprint(path, after) === fingerprint)
+            recordVerifiedDigest(fingerprint, sha256);
+        await file.close();
+        file = undefined;
+        return sha256;
+    }
+    catch {
+        // Any read failure means no digest; the caller reports the executable identity as unavailable.
+        return undefined;
+    }
+    finally {
+        try {
+            await file?.close();
+        }
+        catch { /* The caller receives unavailable; no descriptor authority survives. */ }
+    }
+}
+// The checks that need no file contents: an exact absolute path naming an executable file, or a
+// link that resolves to one.
+async function checkExecutablePath(path) {
+    if (typeof path !== 'string' || !isAbsolute(path) || normalize(path) !== path || path.includes('\0')) {
+        return { state: 'unavailable', reason: 'Executable path must be an exact absolute path' };
+    }
+    let invocation;
+    try {
+        invocation = await lstat(path);
+    }
+    catch (error) {
+        return { state: 'unavailable', reason: `Executable is unavailable: ${path}: ${errorCause(error)}` };
+    }
+    if (!(invocation.isFile() || invocation.isSymbolicLink()) || invocation.isFile() && (invocation.mode & 0o111) === 0) {
+        return { state: 'unavailable', reason: `Executable is unavailable: ${path}` };
+    }
+    try {
+        return { state: 'present', path, canonicalPath: await realpath(path) };
+    }
+    catch (error) {
+        return { state: 'unavailable', reason: `Executable is unavailable: ${path}: ${errorCause(error)}` };
+    }
+}
+export async function resolveExecutablePath(path) {
+    const checked = await checkExecutablePath(path);
+    if (checked.state === 'unavailable')
+        return unavailable(checked.reason);
+    const sha256 = await digestRegularFile(checked.canonicalPath);
+    if (sha256 === undefined)
+        return unavailable(`Executable identity is unavailable: ${path}`);
+    const value = resolvedExecutable({ canonicalPath: checked.canonicalPath, invocationPath: path, sha256, executionMode: 'verified-path' });
+    return value ? { state: 'available', value } : unavailable(`Executable identity is invalid: ${path}`);
+}
+const miss = (reason) => ({ state: 'unavailable', reason });
+// Validates the search path once and tries each directory in order; `probe` decides what a hit is.
+async function searchExecutable(name, env, probe, found) {
+    const selected = searchPath(env);
+    if (selected.kind === 'unreadable')
+        return miss('Executable search path is not readable');
+    const pathValue = selected.path;
+    if (typeof pathValue !== 'string' || pathValue.length === 0 || pathValue.includes('\0') || Buffer.byteLength(pathValue) > 65_536) {
+        return miss('Executable search path is missing or invalid');
+    }
+    const directories = pathValue.split(delimiter);
+    if (directories.length > PATH_ENTRY_LIMIT || directories.some(path => !isAbsolute(path) || normalize(path) !== path)) {
+        return miss('Executable search path must contain bounded absolute directories');
+    }
+    for (const directory of directories) {
+        const result = await probe(join(directory, name));
+        if (found(result))
+            return result;
+    }
+    return miss(`Executable was not found in the supplied search path: ${name}`);
+}
+export async function resolveExecutable(name, env) {
+    if (typeof name !== 'string' || name.length === 0 || name.includes('\0'))
+        return unavailable('Executable name is invalid');
+    if (isAbsolute(name))
+        return resolveExecutablePath(name);
+    if (basename(name) !== name)
+        return unavailable('Executable name must be absolute or a PATH entry name');
+    return searchExecutable(name, env, resolveExecutablePath, result => result.state === 'available');
+}
+/**
+ * Whether a command can be started from `cwd`, found the way a wrapper that changes into `cwd` would
+ * find it, without hashing the file: a command with a slash is relative to `cwd`, a bare name is
+ * looked up on PATH. For callers that report presence rather than run the file.
+ */
+export async function locateExecutable(command, env, cwd) {
+    if (typeof command !== 'string' || command.length === 0 || command.includes('\0'))
+        return miss('Executable name is invalid');
+    if (command.includes('/'))
+        return checkExecutablePath(resolve(cwd, command));
+    return searchExecutable(command, env, checkExecutablePath, result => result.state === 'present');
+}
+export async function resolveGitExecutable(env) {
+    return resolveExecutable('git', env);
+}
+export async function resolveDiskCapacityExecutable() {
+    return resolveExecutablePath(process.execPath);
+}
+export async function resolveDockerExecutable(env) {
+    return resolveExecutable('docker', env);
+}
+export async function resolvePathRemovalExecutable() {
+    return resolveExecutablePath('/bin/rm');
+}

package/dist/environment/generated-application/authorities.d.ts

@@ -0,0 +1,5 @@
+import { type ConsumedWorkApplicationAuthorities, type GeneratedApplicationProjection, type GeneratedEnvironmentCommandInput, type RefusalOutcome, type WorkApplicationAuthoritiesProjection } from './shared.js';
+export declare function generatedApplicationProjection(value: unknown): GeneratedApplicationProjection | undefined;
+export declare function projectWorkApplicationAuthorities(application: GeneratedApplicationProjection): WorkApplicationAuthoritiesProjection | undefined;
+export declare function consumeWorkApplicationAuthorities(projection: WorkApplicationAuthoritiesProjection): ConsumedWorkApplicationAuthorities | undefined;
+export declare function prepareWorkApplicationAuthorities(input: GeneratedEnvironmentCommandInput): Promise<WorkApplicationAuthoritiesProjection | RefusalOutcome>;

package/dist/environment/generated-application/authorities.js

@@ -0,0 +1,61 @@
+import { resolve } from 'node:path';
+import { consumeWorkEnvironmentConfigProjection, loadCockpitConfig, projectWorkEnvironmentConfig } from '../../config/load.js';
+import { CORE_EVALUATOR_ASSET as EVALUATOR_ASSET } from '../../surfaces/core-declarations.js';
+import { nodeAuthority, readAnchoredFile } from '../../generated-environment/transaction.js';
+import { TESTING_GUIDE_REGISTRY, createGateRegistry } from '../../testing/gates.js';
+import { refusalOutcome as refuse } from '../../refusal.js';
+import { MAX_SURFACE_FILE_BYTES, SURFACE_ROOT, defaultAdapters, issuedApplicationProjections, issuedWorkApplicationAuthorities, projectedWorkApplicationAuthorities, readSurfaceAsset, sha256, } from './shared.js';
+import { commandInput } from './prepare.js';
+export function generatedApplicationProjection(value) {
+    return value !== null && typeof value === 'object' && issuedApplicationProjections.has(value)
+        ? value : undefined;
+}
+export function projectWorkApplicationAuthorities(application) {
+    if (application === null || typeof application !== 'object' || projectedWorkApplicationAuthorities.has(application))
+        return undefined;
+    const record = issuedApplicationProjections.get(application);
+    if (!record?.workApplication)
+        return undefined;
+    const projection = { kind: 'work-application-authorities' };
+    projectedWorkApplicationAuthorities.add(application);
+    issuedWorkApplicationAuthorities.set(projection, record.workApplication);
+    return projection;
+}
+export function consumeWorkApplicationAuthorities(projection) {
+    if (projection === null || typeof projection !== 'object')
+        return undefined;
+    const record = issuedWorkApplicationAuthorities.get(projection);
+    if (!record)
+        return undefined;
+    issuedWorkApplicationAuthorities.delete(projection);
+    return record;
+}
+export async function prepareWorkApplicationAuthorities(input) {
+    const request = commandInput(input);
+    if (!request)
+        return refuse('GENERATED_INPUT_INVALID', 'work application input is invalid', 'work');
+    const loaded = await loadCockpitConfig(request.configPath);
+    if (loaded.kind !== 'complete')
+        return {
+            kind: 'refusal', artifact: null, destination: null, result: null, status: 2,
+            diagnostics: [...loaded.diagnostics],
+        };
+    const configProjection = projectWorkEnvironmentConfig(loaded.result);
+    const workEnvironment = configProjection && consumeWorkEnvironmentConfigProjection(configProjection);
+    const node = await nodeAuthority();
+    if (!workEnvironment || !node)
+        return refuse('GENERATED_RENDER_UNAUTHENTICATED', 'work configuration or Node authority is unavailable', request.configPath);
+    const read = await readAnchoredFile(SURFACE_ROOT, EVALUATOR_ASSET, MAX_SURFACE_FILE_BYTES, node, defaultAdapters);
+    const evaluator = readSurfaceAsset(EVALUATOR_ASSET, read);
+    if (!evaluator)
+        return refuse('SURFACE_INPUT_INVALID', 'the shipped evaluator could not be authenticated', EVALUATOR_ASSET);
+    const projection = { kind: 'work-application-authorities' };
+    issuedWorkApplicationAuthorities.set(projection, Object.freeze({
+        workEnvironment,
+        evaluator: Object.freeze({ path: resolve(SURFACE_ROOT, evaluator.path), bytes: evaluator.bytes,
+            sha256: evaluator.sha256, identity: evaluator.identity, restriction: 'instructed' }),
+        installedSkills: Object.freeze([]),
+        testing: Object.freeze({ registry: workEnvironment.testing ? createGateRegistry(workEnvironment.testing.declarations) : TESTING_GUIDE_REGISTRY }),
+    }));
+    return projection;
+}

package/dist/environment/generated-application/bootstrap-skill.d.ts

@@ -0,0 +1,16 @@
+import { type SurfaceTarget } from '../../surfaces/contract.js';
+import type { SurfacePriorOwnedEntry } from '../../surfaces/ownership.js';
+import type { ResolvedExecutable } from '../executable.js';
+import { type GeneratedEnvironmentCommandAdapters, type GeneratedEnvironmentSyncInput, type SelectedBootstrapPublicationAuthority, type SelectedBootstrapResumeInput, type SelectedBootstrapResumeOutcome, type SelectedBootstrapSurfaceInput, type SelectedBootstrapSurfaceOutcome } from './shared.js';
+export declare function prepareSelectedBootstrapSurface(input: SelectedBootstrapSurfaceInput, adapterOverrides?: Partial<GeneratedEnvironmentCommandAdapters>): Promise<SelectedBootstrapSurfaceOutcome>;
+export declare function applySelectedBootstrapSurface(authority: SelectedBootstrapPublicationAuthority): Promise<SelectedBootstrapSurfaceOutcome>;
+export declare function resumeSelectedBootstrapSurface(input: SelectedBootstrapResumeInput, adapterOverrides?: Partial<GeneratedEnvironmentCommandAdapters>): Promise<SelectedBootstrapResumeOutcome>;
+export declare function authenticatedBootstrapPriorSurfaces(root: string, state: NonNullable<GeneratedEnvironmentSyncInput['bootstrapState']>, node: ResolvedExecutable, adapters: GeneratedEnvironmentCommandAdapters): Promise<readonly SurfacePriorOwnedEntry[] | undefined>;
+export declare function unfinishedInitSurfaces(root: string, node: ResolvedExecutable, adapters: GeneratedEnvironmentCommandAdapters): Promise<UnfinishedInit | undefined>;
+export interface UnfinishedInit {
+    readonly root: string;
+    readonly target: SurfaceTarget;
+    readonly published: readonly string[];
+    /** Absent when the files no longer hold what init recorded, so sync cannot take them over. */
+    readonly surfaces: readonly SurfacePriorOwnedEntry[] | undefined;
+}

package/dist/environment/generated-application/bootstrap-skill.js

@@ -0,0 +1,328 @@
+import { lstat, realpath } from 'node:fs/promises';
+import { isAbsolute, join, resolve } from 'node:path';
+import { SURFACE_TARGETS } from '../../surfaces/contract.js';
+import { CORE_PROCEDURE_ASSETS as PROCEDURE_ASSETS, CORE_SKILL_ASSETS as SKILL_ASSETS, shippedSkillSources, } from '../../surfaces/core-declarations.js';
+import { SHIPPED_SETUP_SKILL, inspectSkillSet, projectInspectedSkillOutputs } from '../../surfaces/skill-contract.js';
+import { nodeAuthority, readAnchoredEntry, readAnchoredBatches, expectedState, admitPublicationPlan, runPublicationPlan, } from '../../generated-environment/transaction.js';
+import { errorCause, RefusalError } from '../contract.js';
+import { authenticateStatePublication, readState, selectBootstrapStateRoot } from '../state.js';
+import { exactKeys } from '../../exact-keys.js';
+import { refusalOutcome as refuse } from '../../refusal.js';
+import { MAX_OWNERSHIP_BYTES, MAX_SURFACE_FILE_BYTES, OWNERSHIP_PATH, SURFACE_ROOT, consumedBootstrapStatePublications, issuedSelectedBootstrapAuthorities, mergedAdapters, ownRecord, readSurfaceAsset, sha256, sourceIdentity, } from './shared.js';
+import { prepare, readOwnership } from './prepare.js';
+function selectedBootstrapInput(input) {
+    const record = ownRecord(input);
+    if (!record || !exactKeys(record, ['root', 'target', 'tools']) || typeof record.root !== 'string'
+        || !isAbsolute(record.root) || resolve(record.root) !== record.root
+        || !SURFACE_TARGETS.includes(record.target)
+        || !Array.isArray(record.tools) || record.tools[0] !== record.target
+        || new Set(record.tools).size !== record.tools.length
+        || record.tools.some(tool => !SURFACE_TARGETS.includes(tool)))
+        return undefined;
+    return { root: record.root, target: record.target, tools: [...record.tools] };
+}
+/** The shipped skill sources with the packaged collection and procedures that authenticate them. */
+function bootstrapSkillInput(assets, tools) {
+    const skills = shippedSkillSources(assets, tools);
+    const collection = assets.get('skills/collection.json');
+    const procedures = PROCEDURE_ASSETS.map(path => assets.get(path));
+    if (!skills || !collection || procedures.some(row => row === undefined))
+        return undefined;
+    const pick = ({ path, bytes, sha256: digest }) => ({ path, bytes, sha256: digest });
+    return { sources: skills.flatMap(skill => skill.sources), collection: pick(collection),
+        procedures: procedures.map(pick), tools };
+}
+async function selectedBootstrapAssets(node, adapters) {
+    const reads = await readAnchoredBatches(SURFACE_ROOT, SKILL_ASSETS.map(path => ({
+        path, maxBytes: MAX_SURFACE_FILE_BYTES, action: 'read-file',
+    })), node, adapters);
+    if (!reads || reads.kind !== 'complete' || reads.results.length !== SKILL_ASSETS.length)
+        return undefined;
+    const assets = SKILL_ASSETS.map((path, index) => readSurfaceAsset(path, reads.results[index]));
+    return assets.every((asset) => asset !== undefined) ? assets : undefined;
+}
+async function selectedBootstrapRecordCurrent(record) {
+    try {
+        const root = await lstat(record.root);
+        if (!root.isDirectory() || root.isSymbolicLink() || root.dev !== record.rootIdentity.dev || root.ino !== record.rootIdentity.ino)
+            return false;
+        const reads = await readAnchoredBatches(SURFACE_ROOT, record.assets.map(asset => ({
+            path: asset.path, maxBytes: MAX_SURFACE_FILE_BYTES, action: 'read-file',
+        })), record.node, record.adapters);
+        const state = record.bootstrapState && await readState(record.bootstrapState.address);
+        return (!record.bootstrapState || state?.kind === 'complete'
+            && JSON.stringify(state.value) === JSON.stringify(record.bootstrapState.record))
+            && !!reads && reads.kind === 'complete' && reads.results.length === record.assets.length
+            && reads.results.every((read, index) => read.kind === 'complete' && read.sha256 === record.assets[index].sha256
+                && sourceIdentity(read.identity) === sourceIdentity(record.assets[index].identity));
+    }
+    catch {
+        // a failed re-observation means the inputs are no longer authenticated; the caller refuses.
+        return false;
+    }
+}
+export async function prepareSelectedBootstrapSurface(input, adapterOverrides = {}) {
+    const captured = selectedBootstrapInput(input);
+    if (!captured)
+        return refuse('GENERATED_INPUT_INVALID', 'selected bootstrap input is invalid', 'bootstrap');
+    const adapters = mergedAdapters(adapterOverrides);
+    let root;
+    let rootIdentity;
+    try {
+        root = await realpath(captured.root);
+        const status = await lstat(root);
+        if (root !== captured.root || !status.isDirectory() || status.isSymbolicLink())
+            throw new RefusalError('root');
+        rootIdentity = { dev: status.dev, ino: status.ino };
+    }
+    catch (error) {
+        return refuse('GENERATED_INPUT_INVALID', `selected bootstrap root is not a canonical directory: ${errorCause(error)}`, captured.root);
+    }
+    const node = await nodeAuthority();
+    const assets = node && await selectedBootstrapAssets(node, adapters);
+    if (!node || !assets)
+        return refuse('SURFACE_INPUT_INVALID', 'packaged bootstrap assets could not be authenticated', 'bootstrap');
+    const skillInput = bootstrapSkillInput(new Map(assets.map(asset => [asset.path, asset])), captured.tools);
+    if (!skillInput)
+        return refuse('SURFACE_INPUT_INVALID', 'packaged bootstrap assets are incomplete', 'bootstrap');
+    const { sources } = skillInput;
+    const inspection = await inspectSkillSet(skillInput);
+    if (inspection.kind !== 'complete')
+        return refuse('SURFACE_INPUT_INVALID', 'packaged bootstrap skill set was refused', 'bootstrap');
+    const inspected = projectInspectedSkillOutputs(inspection, captured.tools, SHIPPED_SETUP_SKILL);
+    if (inspected.kind !== 'complete')
+        return refuse('SURFACE_INPUT_INVALID', 'selected bootstrap output set was refused', captured.target);
+    const reads = await readAnchoredBatches(root, inspected.files.map(file => ({
+        path: file.path, maxBytes: MAX_SURFACE_FILE_BYTES, action: 'read-entry',
+    })), node, adapters);
+    if (!reads || reads.kind !== 'complete' || reads.results.length !== inspected.files.length) {
+        return refuse('SURFACE_STATE_CONFLICT', 'selected bootstrap destinations could not be authenticated', captured.target);
+    }
+    const mutations = [];
+    for (const [index, file] of inspected.files.entries()) {
+        const current = reads.results[index];
+        if (current.kind !== 'missing' && current.kind !== 'file')
+            return refuse('SURFACE_STATE_CONFLICT', 'selected bootstrap destination is not a regular file or missing', file.path);
+        if (current.kind === 'file' && current.sha256 !== file.sha256)
+            return refuse('SURFACE_STATE_CONFLICT', 'selected bootstrap destination contains unmanaged bytes', file.path);
+        if (current.kind === 'missing')
+            mutations.push({ path: file.path, phase: 'desired', operation: 'write-file',
+                bytes: file.bytes, sha256: file.sha256, expected: { kind: 'missing' } });
+    }
+    const admitted = await admitPublicationPlan({ mode: 'bootstrap', root, rootIdentity, node, inspected,
+        mutations }, adapters);
+    if (admitted.kind !== 'complete')
+        return admitted;
+    const sourceRows = sources.map(source => ({ path: source.path, sha256: sha256(source.bytes) }));
+    const files = inspected.files.map(file => ({ path: file.path, sha256: file.sha256 }));
+    const previewSha256 = sha256(JSON.stringify({ target: captured.target, sources: sourceRows, files }));
+    const result = { root, target: captured.target, sources: sourceRows, files,
+        previewSha256, changes: admitted.plan.changes };
+    const authority = { kind: 'selected-bootstrap-publication-authority' };
+    issuedSelectedBootstrapAuthorities.set(authority, Object.freeze({ root, rootIdentity, target: captured.target, node,
+        assets: Object.freeze(assets.map(({ path, sha256: digest, identity }) => ({ path, sha256: digest, identity }))),
+        inspected, result, plan: admitted.plan, adapters }));
+    return { kind: 'complete', artifact: null, destination: null, diagnostics: [], result, authority, status: 0 };
+}
+export async function applySelectedBootstrapSurface(authority) {
+    const record = authority !== null && typeof authority === 'object' ? issuedSelectedBootstrapAuthorities.get(authority) : undefined;
+    if (!record)
+        return refuse('GENERATED_PUBLICATION_FAILED', 'selected bootstrap publication authority is unknown or already consumed', 'bootstrap');
+    issuedSelectedBootstrapAuthorities.delete(authority);
+    const outcome = await runPublicationPlan(record.plan, { execute: record.adapters.execute,
+        revalidate: async () => selectedBootstrapRecordCurrent(record) });
+    if (outcome.kind !== 'complete')
+        return outcome;
+    return { kind: 'complete', artifact: null, destination: null, diagnostics: [],
+        result: record.result, authority, status: 0 };
+}
+export async function resumeSelectedBootstrapSurface(input, adapterOverrides = {}) {
+    const captured = selectedBootstrapInput({ root: input.root, target: input.target, tools: input.tools });
+    const durable = await readState(input.address);
+    if (!captured || durable.kind !== 'complete' || durable.value.kind !== 'bootstrap'
+        || durable.value.value.checkoutRoot !== captured.root || durable.value.target !== captured.target
+        || input.address.checkoutRoot !== captured.root || input.address.target !== captured.target
+        || durable.value.value.stage === 'surface-previewed')
+        return refuse('GENERATED_OWNERSHIP_INVALID', 'bootstrap resume requires the current durable state, root and target', 'bootstrap');
+    const adapters = mergedAdapters(adapterOverrides);
+    let rootIdentity;
+    try {
+        const status = await lstat(captured.root);
+        if (!status.isDirectory() || status.isSymbolicLink() || await realpath(captured.root) !== captured.root)
+            throw new RefusalError('root');
+        rootIdentity = { dev: status.dev, ino: status.ino };
+    }
+    catch (error) {
+        return refuse('GENERATED_INPUT_INVALID', `selected bootstrap root is not a canonical directory: ${errorCause(error)}`, captured.root);
+    }
+    const node = await nodeAuthority();
+    if (!node)
+        return refuse('SURFACE_INPUT_INVALID', 'bootstrap resume could not authenticate the node executable', 'bootstrap');
+    const ownership = await readAnchoredEntry(captured.root, OWNERSHIP_PATH, MAX_OWNERSHIP_BYTES, node, adapters);
+    if (ownership.kind !== 'missing' && ownership.kind !== 'file')
+        return refuse('GENERATED_OWNERSHIP_INVALID', 'bootstrap resume ownership could not be read safely', OWNERSHIP_PATH);
+    const assets = await selectedBootstrapAssets(node, adapters);
+    if (!assets)
+        return refuse('SURFACE_INPUT_INVALID', 'bootstrap resume packaged assets could not be authenticated', 'bootstrap');
+    const skillInput = bootstrapSkillInput(new Map(assets.map(asset => [asset.path, asset])), captured.tools);
+    if (!skillInput)
+        return refuse('SURFACE_INPUT_INVALID', 'bootstrap resume packaged assets are incomplete', 'bootstrap');
+    const { sources } = skillInput;
+    const inspection = await inspectSkillSet(skillInput);
+    if (inspection.kind !== 'complete')
+        return refuse('SURFACE_INPUT_INVALID', 'bootstrap resume skill set was refused', 'bootstrap');
+    const inspected = projectInspectedSkillOutputs(inspection, captured.tools, SHIPPED_SETUP_SKILL);
+    if (inspected.kind !== 'complete')
+        return refuse('SURFACE_INPUT_INVALID', 'bootstrap resume output projection was refused', captured.target);
+    const sourceRows = sources.map(source => ({ path: source.path, sha256: sha256(source.bytes) }));
+    const files = inspected.files.map(file => ({ path: file.path, sha256: file.sha256 }));
+    const previewSha256 = sha256(JSON.stringify({ target: captured.target, sources: sourceRows, files }));
+    const state = durable.value.value;
+    const sourcesCurrent = JSON.stringify(state.sources) === JSON.stringify(sourceRows)
+        && JSON.stringify(state.published) === JSON.stringify(files) && state.previewSha256 === previewSha256;
+    if (ownership.kind === 'missing') {
+        if (sourcesCurrent)
+            return { kind: 'pending', status: 0, diagnostics: [],
+                result: null, canonicalOwnership: false };
+        const priorPreviewSha256 = sha256(JSON.stringify({ target: captured.target, sources: state.sources, files: state.published }));
+        if (input.expectedRevision !== durable.value.revision || input.expectedCommandSha256 !== state.commandSha256
+            || priorPreviewSha256 !== state.previewSha256 || state.stage !== 'surface-published'
+            || JSON.stringify(state.published.map(row => row.path)) !== JSON.stringify(files.map(row => row.path)))
+            return refuse('GENERATED_SOURCE_CHANGED', 'bootstrap resume package sources differ from the accepted durable preview', 'bootstrap');
+        const reads = await readAnchoredBatches(captured.root, inspected.files.map(file => ({
+            path: file.path, maxBytes: MAX_SURFACE_FILE_BYTES, action: 'read-entry',
+        })), node, adapters);
+        if (!reads || reads.kind !== 'complete' || reads.results.length !== inspected.files.length)
+            return refuse('SURFACE_STATE_CONFLICT', 'bootstrap refresh destinations could not be authenticated', captured.target);
+        const mutations = [];
+        for (const [index, file] of inspected.files.entries()) {
+            const current = reads.results[index];
+            const prior = state.published[index];
+            if (current.kind !== 'file' || current.sha256 !== prior.sha256 && current.sha256 !== file.sha256)
+                return refuse('SURFACE_STATE_CONFLICT', 'bootstrap refresh destination differs from its authenticated publication', file.path);
+            if (current.sha256 === file.sha256)
+                continue;
+            const expected = expectedState(current);
+            if (!expected)
+                return refuse('SURFACE_STATE_CONFLICT', 'bootstrap refresh destination could not be authenticated', file.path);
+            mutations.push({ path: file.path, phase: 'desired', operation: 'write-file',
+                bytes: file.bytes, sha256: file.sha256, expected });
+        }
+        const admitted = await admitPublicationPlan({ mode: 'bootstrap', root: captured.root, rootIdentity, node, inspected,
+            mutations, refresh: { address: input.address,
+                revision: durable.value.revision, commandSha256: state.commandSha256 } }, adapters);
+        if (admitted.kind !== 'complete')
+            return admitted;
+        const result = { root: captured.root, target: captured.target,
+            sources: sourceRows, files, previewSha256, changes: admitted.plan.changes };
+        const authority = { kind: 'selected-bootstrap-publication-authority' };
+        issuedSelectedBootstrapAuthorities.set(authority, Object.freeze({ root: captured.root, rootIdentity,
+            target: captured.target, node,
+            assets: Object.freeze(assets.map(({ path, sha256: digest, identity }) => ({ path, sha256: digest, identity }))),
+            inspected, result, plan: admitted.plan, adapters,
+            bootstrapState: Object.freeze({ address: input.address, record: durable.value }),
+        }));
+        return { kind: 'refresh', status: 0, diagnostics: [], result, authority,
+            canonicalOwnership: false };
+    }
+    if (ownership.kind !== 'file')
+        return refuse('GENERATED_OWNERSHIP_INVALID', 'bootstrap resume ownership changed after classification', OWNERSHIP_PATH);
+    if (!sourcesCurrent)
+        return refuse('GENERATED_SOURCE_CHANGED', 'bootstrap resume package sources differ from the accepted durable preview', 'bootstrap');
+    const base = await prepare({ configPath: join(captured.root, 'cockpit.toml') }, adapters);
+    if ('status' in base)
+        return base;
+    const canonical = await readOwnership(base, adapters);
+    if (base.root !== captured.root || canonical.kind !== 'complete'
+        || canonical.manifest.format !== 'cockpit-generated-ownership/v3' || canonical.sha256 !== ownership.sha256)
+        return refuse('GENERATED_OWNERSHIP_INVALID', 'bootstrap resume requires canonical ownership bound to the current checkout and configuration', OWNERSHIP_PATH);
+    const current = await readAnchoredEntry(captured.root, OWNERSHIP_PATH, MAX_OWNERSHIP_BYTES, node, adapters);
+    const refreshed = await readState(input.address);
+    if (current.kind !== 'file' || current.sha256 !== ownership.sha256
+        || sourceIdentity(current.identity) !== sourceIdentity(ownership.identity)
+        || refreshed.kind !== 'complete' || JSON.stringify(refreshed.value) !== JSON.stringify(durable.value))
+        return refuse('GENERATED_SOURCE_CHANGED', 'bootstrap resume ownership or state changed during checking', 'bootstrap');
+    return { kind: 'complete', status: 0, diagnostics: [], canonicalOwnership: true,
+        result: { root: captured.root, target: captured.target, sources: sourceRows, files, previewSha256,
+            changes: [] } };
+}
+export async function authenticatedBootstrapPriorSurfaces(root, state, node, adapters) {
+    const publication = state.publication;
+    if (publication === null || typeof publication !== 'object' || consumedBootstrapStatePublications.has(publication))
+        return undefined;
+    const authenticated = authenticateStatePublication(state);
+    if (!authenticated || authenticated.status !== 'complete' || authenticated.record.kind !== 'bootstrap')
+        return undefined;
+    const record = authenticated.record;
+    if (record.target !== state.address.target || state.address.checkoutRoot !== root)
+        return undefined;
+    const surfaces = await bootstrapPublishedSurfaces(root, record, node, adapters);
+    if (surfaces)
+        consumedBootstrapStatePublications.add(publication);
+    return surfaces;
+}
+// A plain sync between an interrupted init and its rerun met init's own setup skill files with no
+// ownership record and refused them, and its remedy had an agent delete them. The bootstrap record
+// sync reads here comes from this user's private state root, scoped to this cockpit root, and the
+// files must still hold exactly the bytes init published from the installed package.
+export async function unfinishedInitSurfaces(root, node, adapters) {
+    if (process.platform !== 'darwin' && process.platform !== 'linux')
+        return undefined;
+    for (const target of SURFACE_TARGETS) {
+        const namespace = await selectBootstrapStateRoot({ platform: process.platform, home: process.env.HOME,
+            xdgStateHome: process.env.XDG_STATE_HOME, checkoutRoot: root, target });
+        if (namespace.kind !== 'complete')
+            return undefined;
+        const read = await readState(namespace.value.paths.bootstrap(target));
+        if (read.kind === 'complete')
+            return { root, target, published: read.value.value.published.map(row => row.path),
+                surfaces: await bootstrapPublishedSurfaces(root, read.value, node, adapters) };
+    }
+    return undefined;
+}
+async function bootstrapPublishedSurfaces(root, record, node, adapters) {
+    if (record.kind !== 'bootstrap' || record.value.stage === 'surface-previewed' || record.value.checkoutRoot !== root
+        || record.value.target !== record.target)
+        return undefined;
+    const assets = await selectedBootstrapAssets(node, adapters);
+    if (!assets)
+        return undefined;
+    // The record names no tools, so they are the targets whose setup skill it published, in published order.
+    const allTools = bootstrapSkillInput(new Map(assets.map(asset => [asset.path, asset])), SURFACE_TARGETS);
+    const allInspection = allTools && await inspectSkillSet(allTools);
+    const allProjection = allInspection?.kind === 'complete'
+        ? projectInspectedSkillOutputs(allInspection, SURFACE_TARGETS, SHIPPED_SETUP_SKILL) : undefined;
+    if (allProjection?.kind !== 'complete')
+        return undefined;
+    const targetByPath = new Map(allProjection.files.map(file => [file.path, file.target]));
+    const tools = [...new Set(record.value.published.map(row => targetByPath.get(row.path)))];
+    if (tools.some(tool => tool === undefined))
+        return undefined;
+    const skillInput = bootstrapSkillInput(new Map(assets.map(asset => [asset.path, asset])), tools);
+    if (!skillInput)
+        return undefined;
+    const sourceRows = skillInput.sources.map(source => ({ path: source.path, sha256: sha256(source.bytes) }));
+    if (JSON.stringify(sourceRows) !== JSON.stringify(record.value.sources))
+        return undefined;
+    const inspection = await inspectSkillSet(skillInput);
+    if (inspection.kind !== 'complete')
+        return undefined;
+    const inspected = projectInspectedSkillOutputs(inspection, tools, SHIPPED_SETUP_SKILL);
+    if (inspected.kind !== 'complete')
+        return undefined;
+    const files = inspected.files;
+    const published = files.map(file => ({ path: file.path, sha256: file.sha256 }));
+    if (JSON.stringify(published) !== JSON.stringify(record.value.published))
+        return undefined;
+    const reads = await readAnchoredBatches(root, files.map(file => ({
+        path: file.path, maxBytes: MAX_SURFACE_FILE_BYTES, action: 'read-entry',
+    })), node, adapters);
+    if (!reads || reads.kind !== 'complete' || reads.results.length !== files.length
+        || reads.results.some((read, index) => read.kind !== 'file' || read.sha256 !== files[index].sha256))
+        return undefined;
+    return files.map(file => ({
+        kind: 'file', path: file.path, harnesses: [file.target], scope: 'always',
+        capability: 'instructed', writer: 'cockpit', schemaVersion: 1,
+        ownership: 'whole-file', sha256: file.sha256,
+    }));
+}

package/dist/environment/generated-application/check.d.ts

@@ -0,0 +1,13 @@
+import { type PublicationPlan } from '../../generated-environment/transaction.js';
+import { type GeneratedEnvironmentCommandAdapters, type GeneratedEnvironmentCommandInput, type GeneratedEnvironmentCommandOutcome, type GeneratedEnvironmentCurrentness, type GeneratedEnvironmentRepairAuthority, type PreparedEnvironment } from './shared.js';
+interface RepairRecord {
+    readonly prepared: PreparedEnvironment;
+    readonly plan: PublicationPlan;
+    readonly adapters: GeneratedEnvironmentCommandAdapters;
+}
+export declare const issuedRepairs: WeakMap<GeneratedEnvironmentRepairAuthority, RepairRecord>;
+export declare function issueRepairAuthority(record: RepairRecord): GeneratedEnvironmentRepairAuthority;
+export declare function prepareGeneratedEnvironmentCurrentness(input: GeneratedEnvironmentCommandInput, adapterOverrides?: Partial<GeneratedEnvironmentCommandAdapters>): Promise<GeneratedEnvironmentCurrentness>;
+export declare function checkCanonicalGeneratedEnvironment(input: GeneratedEnvironmentCommandInput, seed?: PreparedEnvironment, adapters?: GeneratedEnvironmentCommandAdapters): Promise<GeneratedEnvironmentCommandOutcome>;
+export declare function checkGeneratedEnvironment(input: GeneratedEnvironmentCommandInput, adapterOverrides?: Partial<GeneratedEnvironmentCommandAdapters>): Promise<GeneratedEnvironmentCommandOutcome>;
+export {};