@b00dea/cockpit 0.0.0-stage → 0.1.1

package/dist/generated-environment/command.js

@@ -0,0 +1,75 @@
+import { createInterface } from 'node:readline/promises';
+import { renderHumanValue } from '../diagnostics.js';
+import { loadOperatorPolicy, runSyncOperatorApplication } from '../environment/operator-application.js';
+import { runSyncAdoption } from './adopt.js';
+import { applySelectedBootstrapSurface as applyBootstrap, prepareSelectedBootstrapSurface as prepareBootstrap, resumeSelectedBootstrapSurface as resumeBootstrap, } from '../environment/generated-application/bootstrap-skill.js';
+import { checkGeneratedEnvironment as check, prepareGeneratedEnvironmentCurrentness as prepareCurrentness, } from '../environment/generated-application/check.js';
+import {} from '../environment/generated-application/shared.js';
+import { applyGeneratedEnvironmentRepair as applyRepair, syncGeneratedEnvironment as synchronize, syncTeamGeneratedEnvironment as synchronizeTeam, } from '../environment/generated-application/sync.js';
+export function prepareSelectedBootstrapSurface(input, adapters) {
+    return prepareBootstrap(input, adapters);
+}
+export function resumeSelectedBootstrapSurface(input, adapters) {
+    return resumeBootstrap(input, adapters);
+}
+export function applySelectedBootstrapSurface(authority) {
+    return applyBootstrap(authority);
+}
+export function prepareGeneratedEnvironmentCurrentness(input, adapters) {
+    return prepareCurrentness(input, adapters);
+}
+export function applyGeneratedEnvironmentRepair(authority, options) {
+    return applyRepair(authority, options);
+}
+export function syncGeneratedEnvironment(input, adapters) {
+    return synchronize(input, adapters);
+}
+export function syncTeamGeneratedEnvironment(input, adapters) {
+    return synchronizeTeam(input, adapters);
+}
+/** `sync --adopt`: record the adoption, then run the ordinary sync that renders the merge. */
+export function adoptAndSyncGeneratedEnvironment(input) {
+    return runSyncAdoption(input, request => synchronizeTeam(request));
+}
+export function checkGeneratedEnvironment(input) {
+    return check(input);
+}
+async function confirmStaleRemoval(io, request) {
+    if (io.confirmStaleRemoval)
+        return io.confirmStaleRemoval(request);
+    if (!io.stdin)
+        return undefined;
+    io.stderr.write(renderHumanValue(request));
+    const prompt = createInterface({ input: io.stdin, output: io.stderr, terminal: true });
+    try {
+        const answer = await prompt.question('Type the exact stale-removal digest to approve this sync: ');
+        return answer.trim();
+    }
+    finally {
+        prompt.close();
+    }
+}
+export async function runSyncOperatorCommand(input, options, io, handler, policy = loadOperatorPolicy) {
+    return runSyncOperatorApplication(input, {
+        ...options,
+        terminal: io.confirmStaleRemoval !== undefined || io.stdin?.isTTY === true,
+    }, {
+        synchronize: handler,
+        confirmStaleRemoval: (request) => confirmStaleRemoval(io, request),
+        policy,
+        confirmPolicyWeakening: async (request) => {
+            if (io.confirmPolicyWeakening)
+                return io.confirmPolicyWeakening(request);
+            if (!io.stdin)
+                return undefined;
+            io.stderr.write(renderHumanValue({ weakens: request.weakened.map(row => `${row.field}: ${row.from} -> ${row.to}`), digest: request.digest }));
+            const prompt = createInterface({ input: io.stdin, output: io.stderr, terminal: true });
+            try {
+                return (await prompt.question('Type the digest to accept this weaker policy: ')).trim();
+            }
+            finally {
+                prompt.close();
+            }
+        },
+    });
+}

package/dist/generated-environment/transaction.d.ts

@@ -0,0 +1,186 @@
+import type { Diagnostic } from '../diagnostics.js';
+import { type ExecuteProbeOutcome } from '../environment-exec/execute.js';
+import { type ExecutionStep } from '../environment/contract.js';
+import type { ResolvedExecutable } from '../environment/executable.js';
+import { type BootstrapStateAddress } from '../environment/state.js';
+import { type OwnershipAuthority } from '../surfaces/ownership.js';
+import { type InspectedBootstrapOutputs } from '../surfaces/skill-contract.js';
+import type { SurfaceChange } from '../surfaces/sync.js';
+export interface PublicationAdapters {
+    readonly execute: (step: ExecutionStep) => Promise<ExecuteProbeOutcome>;
+    readonly authorizeStaleRemoval?: (request: GeneratedStaleRemovalApprovalRequest) => Promise<GeneratedStaleRemovalApproval | undefined>;
+}
+interface PublicationChange {
+    readonly operation: 'write' | 'remove';
+    readonly path: string;
+}
+export interface PublicationRefusal {
+    readonly kind: 'refusal';
+    readonly artifact: null;
+    readonly destination: null;
+    readonly result: null;
+    readonly status: 2;
+    readonly diagnostics: readonly Diagnostic[];
+}
+export interface GeneratedStaleRemovalApprovalEntry {
+    readonly path: string;
+    readonly operation: 'write-file' | 'remove-file' | 'remove-symlink';
+    readonly current: Readonly<{
+        readonly kind: 'file' | 'symlink';
+        readonly sha256?: string;
+        readonly target?: string;
+        readonly dev: number;
+        readonly ino: number;
+    }>;
+    readonly resultSha256?: string;
+}
+export interface GeneratedStaleRemovalApprovalRequest {
+    readonly format: 'cockpit-stale-removal-request/v1';
+    readonly cockpitId: string;
+    readonly generation: string;
+    readonly sourceSha256: string;
+    readonly entries: readonly GeneratedStaleRemovalApprovalEntry[];
+    readonly digest: string;
+}
+export interface GeneratedStaleRemovalApproval {
+    readonly format: 'cockpit-stale-removal-approval/v1';
+    readonly digest: string;
+}
+export interface DirectoryIdentity {
+    readonly dev: number;
+    readonly ino: number;
+}
+export interface FileIdentity {
+    readonly root: DirectoryIdentity;
+    readonly chain: readonly DirectoryIdentity[];
+    readonly file: DirectoryIdentity;
+}
+type NodeAuthority = ResolvedExecutable;
+export declare function nodeAuthority(): Promise<NodeAuthority | undefined>;
+export type AnchoredRead = Readonly<{
+    kind: 'complete';
+    bytes: Buffer;
+    sha256: string;
+    identity: FileIdentity;
+}> | Readonly<{
+    kind: 'missing';
+}> | Readonly<{
+    kind: 'invalid';
+}>;
+export type AnchoredEntry = Readonly<{
+    kind: 'missing' | 'other';
+}> | Readonly<{
+    kind: 'file';
+    bytes: Buffer;
+    sha256: string;
+    identity: FileIdentity;
+    mode: number;
+}> | Readonly<{
+    kind: 'symlink';
+    target: string;
+    identity: DirectoryIdentity;
+}> | Readonly<{
+    kind: 'invalid';
+}>;
+export declare function readAnchoredFile(root: string, path: string, maxBytes: number, node: NodeAuthority, adapters: PublicationAdapters, deadline?: number): Promise<AnchoredRead>;
+export declare function readAnchoredEntry(root: string, path: string, maxBytes: number, node: NodeAuthority, adapters: PublicationAdapters): Promise<AnchoredEntry>;
+export type AnchoredRelocation = Readonly<{
+    kind: 'complete';
+    sha256: string;
+}> | Readonly<{
+    kind: 'refusal';
+    recovery: 'unchanged' | 'indeterminate';
+    failure?: string;
+    recoveryFailures?: readonly string[];
+    retainedPaths?: readonly string[];
+}>;
+/** Move one authenticated regular file to a portable authored destination through the publication helper. */
+export declare function relocateAnchoredFile(root: string, sourcePath: string, destinationPath: string, maxBytes: number, expectedSha256: string, node: NodeAuthority, adapters: PublicationAdapters): Promise<AnchoredRelocation>;
+/** Confirm or restore the original side of an anchored relocation without following either path. */
+export declare function restoreAnchoredFile(root: string, originalPath: string, relocatedPath: string, maxBytes: number, expectedSha256: string, node: NodeAuthority, adapters: PublicationAdapters): Promise<AnchoredRelocation>;
+interface AnchoredBatchReadRequest {
+    readonly path: string;
+    readonly maxBytes: number;
+    readonly action: 'read-file' | 'read-entry';
+}
+export type AnchoredBatchReadResult = AnchoredRead | AnchoredEntry;
+type AnchoredBatchOutcome = Readonly<{
+    kind: 'complete';
+    results: readonly AnchoredBatchReadResult[];
+}> | Readonly<{
+    kind: 'invalid';
+    index: number;
+}>;
+export declare function readAnchoredBatches(root: string, requests: readonly AnchoredBatchReadRequest[], node: NodeAuthority, adapters: PublicationAdapters, deadline?: number): Promise<AnchoredBatchOutcome | undefined>;
+export declare function readAnchoredConfigSource(root: string, path: string, node: NodeAuthority, adapters: PublicationAdapters, deadline?: number): Promise<{
+    bytes: Buffer;
+    sha256: string;
+    identity: FileIdentity;
+} | undefined>;
+export declare function portablePublicationPaths(paths: readonly string[]): boolean;
+export interface ExpectedEntryState {
+    readonly kind: 'missing' | 'file' | 'symlink';
+    readonly sha256?: string;
+    readonly target?: string;
+    readonly identity?: DirectoryIdentity;
+}
+export interface PublicationMutation {
+    readonly path: string;
+    readonly phase: 'desired' | 'stale' | 'ledger';
+    readonly operation: 'write-file' | 'write-symlink' | 'remove-file' | 'remove-symlink';
+    readonly expected: ExpectedEntryState;
+    readonly bytes?: string;
+    readonly sha256?: string;
+    readonly target?: string;
+    readonly compactAnchor?: string;
+}
+export declare function expectedState(entry: AnchoredEntry): ExpectedEntryState | undefined;
+export interface PublicationPlan {
+    readonly changes: readonly PublicationChange[];
+    readonly staleRemoval?: GeneratedStaleRemovalApprovalRequest;
+}
+export interface PublicationPlanInput {
+    readonly authority: OwnershipAuthority;
+    readonly generation: string;
+    readonly sourceSha256: string;
+    readonly rootIdentity: DirectoryIdentity;
+    readonly node: ResolvedExecutable;
+    readonly mode: 'sync';
+    readonly ledgerExpected: ExpectedEntryState;
+    readonly nextLedgerBytes: string;
+    readonly mutations: readonly PublicationMutation[];
+    readonly surfaceActions?: readonly SurfaceChange[];
+}
+export interface BootstrapPublicationPlanInput {
+    readonly mode: 'bootstrap';
+    readonly root: string;
+    readonly rootIdentity: DirectoryIdentity;
+    readonly node: ResolvedExecutable;
+    readonly inspected: InspectedBootstrapOutputs;
+    readonly mutations: readonly PublicationMutation[];
+    readonly refresh?: Readonly<{
+        readonly address: BootstrapStateAddress;
+        readonly revision: number;
+        readonly commandSha256: string;
+    }>;
+}
+type AdmittedPublicationPlanInput = PublicationPlanInput | BootstrapPublicationPlanInput;
+export interface PublicationRunAdapters extends PublicationAdapters {
+    readonly dryRun?: boolean;
+    readonly revalidate: (deadline?: number, stage?: 'preview' | 'before-stage' | 'before-publish' | 'after-publish') => Promise<boolean | PublicationRefusal>;
+}
+export type PublicationOutcome = PublicationRefusal | Readonly<{
+    kind: 'complete';
+    changes: readonly PublicationChange[];
+    committedPaths: readonly string[];
+    staleRemoval?: GeneratedStaleRemovalApprovalRequest;
+}>;
+/** Admit exact classified leaves against the observed durable ledger, never raw delete authority. */
+export declare function admitPublicationPlan(input: AdmittedPublicationPlanInput, adapters: PublicationAdapters): Promise<PublicationRefusal | Readonly<{
+    kind: 'complete';
+    plan: PublicationPlan;
+}>>;
+/** Asks for approval before another owner writes; the run reuses this answer instead of asking again. */
+export declare function authorizePublicationPlan(plan: PublicationPlan, adapters: PublicationAdapters): Promise<true | PublicationRefusal>;
+export declare function runPublicationPlan(plan: PublicationPlan, adapters: PublicationRunAdapters): Promise<PublicationOutcome>;
+export {};