@b00dea/cockpit 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,484 @@
+import { type FixContext } from '../../fix-catalogue.js';
+import { proposeGeneratedEnvironmentRepair } from '../../repair.js';
+import { observeConfigSource, type ConsumedWorkEnvironmentConfig } from '../../config/load.js';
+import type { BrowserRuntimeProjection } from '../../browser/runtime.js';
+import type { Diagnostic } from '../../diagnostics.js';
+import { type ExecuteProbeOutcome } from '../../environment-exec/execute.js';
+import type { DerivedRegistry } from '../../registry-derivation.js';
+import type { SurfaceFeature, SurfaceSourceFile, SurfaceTarget } from '../../surfaces/contract.js';
+import type { SurfaceGenerationWarning } from '../../surfaces/generator-adapter.js';
+import type { ActiveSurfaceOverride, SurfaceUpgradeFinding } from '../../surfaces/merge.js';
+import { CORE_EVALUATOR_ASSET as EVALUATOR_ASSET, CORE_SKILL_ASSETS as SKILL_ASSETS } from '../../surfaces/core-declarations.js';
+import type { McpDeclaration } from '../../surfaces/mcp.js';
+import { type GeneratedPathFact, type GeneratedProducer, type SurfaceDesiredEntry } from '../../surfaces/ownership.js';
+import type { DirectoryGrant, GuideObservation, GuideObservationRequest, StandingCost } from '../../surfaces/projection.js';
+import type { NativeFragmentSet, SurfaceInputEvidence } from '../../surfaces/render.js';
+import type { GuardHandlerIdentity } from '../../guards/local-identity.js';
+import type { InspectedBootstrapOutputs, SkillStandingCost } from '../../surfaces/skill-contract.js';
+import type { AnchoredBatchReadResult, DirectoryIdentity, FileIdentity, GeneratedStaleRemovalApprovalRequest, GeneratedStaleRemovalApproval, PublicationPlan } from '../../generated-environment/transaction.js';
+import { type EnvironmentObservation, type ExecutionStep, type CockpitId } from '../contract.js';
+import type { ResolvedExecutable } from '../executable.js';
+import { stackId } from '../identity.js';
+import type { BootstrapStateAddress, BootstrapStateRecord, StateNamespace, StateResult } from '../state.js';
+import type { GateRegistry } from '../../testing/gates.js';
+import type { GeneratedCheckoutIdentity } from '../setup-observation.js';
+export declare const OWNER = "generated-environment-application";
+export declare const surfaceObservationDeclarations: readonly [{
+    readonly id: 'harness-surfaces';
+    readonly owner: "generated-environment-application";
+    readonly postures: readonly ["environment"];
+    readonly stages: readonly [{
+        readonly stage: 'bootstrap';
+        readonly disposition: 'required';
+    }, {
+        readonly stage: 'steady';
+        readonly disposition: 'required';
+    }];
+    readonly code: "HARNESS_SURFACE_UNAVAILABLE";
+    readonly isIssued: typeof isGeneratedApplicationSurfaceObservation;
+    readonly issuedAt: typeof generatedApplicationSurfaceObservationIssuedAt;
+}, {
+    readonly id: 'directory-grants';
+    readonly owner: "generated-environment-application";
+    readonly postures: readonly ["directory-grants"];
+    readonly stages: readonly [{
+        readonly stage: 'bootstrap';
+        readonly disposition: 'required';
+    }, {
+        readonly stage: 'steady';
+        readonly disposition: 'required';
+    }];
+    readonly code: "DIRECTORY_GRANTS_UNAVAILABLE";
+    readonly isIssued: typeof isGeneratedApplicationSurfaceObservation;
+    readonly issuedAt: typeof generatedApplicationSurfaceObservationIssuedAt;
+}, {
+    readonly id: 'guide-budget';
+    readonly owner: "generated-environment-application";
+    readonly postures: readonly ["environment"];
+    readonly stages: readonly [{
+        readonly stage: 'bootstrap';
+        readonly disposition: 'required';
+    }, {
+        readonly stage: 'steady';
+        readonly disposition: 'required';
+    }];
+    readonly code: "GUIDE_CAP_EXCEEDED";
+    readonly isIssued: typeof isGeneratedApplicationSurfaceObservation;
+    readonly issuedAt: typeof generatedApplicationSurfaceObservationIssuedAt;
+}, {
+    readonly id: 'skill-budget';
+    readonly owner: "generated-environment-application";
+    readonly postures: readonly ["environment"];
+    readonly stages: readonly [{
+        readonly stage: 'bootstrap';
+        readonly disposition: 'required';
+    }, {
+        readonly stage: 'steady';
+        readonly disposition: 'required';
+    }];
+    readonly code: "SKILL_BUDGET_UNAVAILABLE";
+    readonly isIssued: typeof isGeneratedApplicationSurfaceObservation;
+    readonly issuedAt: typeof generatedApplicationSurfaceObservationIssuedAt;
+}];
+export declare const issuedSurfaceObservations: WeakMap<object, number>;
+export interface GeneratedEnvironmentCommandInput {
+    readonly configPath: string;
+}
+export interface GeneratedEnvironmentSyncInput extends GeneratedEnvironmentCommandInput {
+    readonly dryRun?: boolean;
+    readonly bootstrapState?: Readonly<{
+        readonly publication: StateResult<BootstrapStateRecord>;
+        readonly address: BootstrapStateAddress;
+    }>;
+}
+export interface SelectedBootstrapSurfaceInput {
+    readonly root: string;
+    readonly target: SurfaceTarget;
+    /** Every tool in `[surfaces] tools`, `target` first; each gets the setup skill before the interview. */
+    readonly tools: readonly SurfaceTarget[];
+}
+export interface SelectedBootstrapPublicationAuthority {
+    readonly kind: 'selected-bootstrap-publication-authority';
+}
+export interface SelectedBootstrapSurfaceResult {
+    readonly root: string;
+    readonly target: SurfaceTarget;
+    readonly sources: readonly Readonly<{
+        path: string;
+        sha256: string;
+    }>[];
+    readonly files: readonly Readonly<{
+        path: string;
+        sha256: string;
+    }>[];
+    readonly previewSha256: string;
+    readonly changes: readonly GeneratedEnvironmentChange[];
+}
+export type SelectedBootstrapSurfaceOutcome = RefusalOutcome | Readonly<{
+    kind: 'complete';
+    artifact: null;
+    destination: null;
+    diagnostics: readonly Diagnostic[];
+    result: SelectedBootstrapSurfaceResult;
+    authority: SelectedBootstrapPublicationAuthority;
+    status: 0;
+}>;
+export interface SelectedBootstrapResumeInput extends SelectedBootstrapSurfaceInput {
+    readonly address: BootstrapStateAddress;
+    readonly expectedRevision?: number;
+    readonly expectedCommandSha256?: string;
+}
+export type SelectedBootstrapResumeOutcome = RefusalOutcome | Readonly<{
+    kind: 'pending';
+    status: 0;
+    diagnostics: readonly Diagnostic[];
+    result: null;
+    canonicalOwnership: false;
+}> | Readonly<{
+    kind: 'refresh';
+    status: 0;
+    diagnostics: readonly Diagnostic[];
+    result: SelectedBootstrapSurfaceResult;
+    authority: SelectedBootstrapPublicationAuthority;
+    canonicalOwnership: false;
+}> | Readonly<{
+    kind: 'complete';
+    status: 0;
+    diagnostics: readonly Diagnostic[];
+    result: SelectedBootstrapSurfaceResult;
+    canonicalOwnership: true;
+}>;
+export interface GeneratedEnvironmentChange {
+    readonly operation: 'write' | 'remove';
+    readonly path: string;
+}
+export interface GeneratedEnvironmentCommandAdapters {
+    readonly now?: () => string;
+    readonly observeSource: typeof observeConfigSource;
+    readonly execute: (step: ExecutionStep) => Promise<ExecuteProbeOutcome>;
+    readonly authorizeStaleRemoval?: (request: GeneratedStaleRemovalApprovalRequest) => Promise<GeneratedStaleRemovalApproval | undefined>;
+}
+export type { GeneratedStaleRemovalApprovalEntry, GeneratedStaleRemovalApprovalRequest, GeneratedStaleRemovalApproval } from '../../generated-environment/transaction.js';
+export interface OwnedBytes {
+    readonly path: string;
+    readonly bytes: string;
+    readonly sha256: string;
+}
+export interface PreparedEnvironment {
+    readonly root: string;
+    readonly cockpitId: CockpitId;
+    readonly stackId: ReturnType<typeof stackId>;
+    readonly runtimeCheckout?: GeneratedCheckoutIdentity;
+    readonly configPath: string;
+    readonly sourceSha256: string;
+    readonly runtimeSha256: string;
+    readonly configSource: Readonly<{
+        path: string;
+        sha256: string;
+    }>;
+    readonly configSourceIdentity: FileIdentity;
+    readonly generation: string;
+    readonly generated: readonly OwnedBytes[];
+    readonly owned: readonly OwnedBytes[];
+    readonly surfaces: readonly SurfaceDesiredEntry[];
+    readonly compactSurfacePaths: ReadonlySet<string>;
+    readonly configuredHarnesses: readonly string[];
+    readonly activeSurfaceOverrides: readonly ActiveSurfaceOverride[];
+    readonly changedOverrideOriginals: readonly SurfaceUpgradeFinding[];
+    readonly surfaceSelftest?: GeneratedSurfaceSelftestProjection;
+    readonly surfaceHealth?: GeneratedSurfaceHealthEvidence;
+    readonly guideSources: Readonly<{
+        readonly requests: readonly GuideObservationRequest[];
+        readonly observations: readonly GuideObservation[];
+        readonly missing: readonly string[];
+    }>;
+    readonly sourceEvidence: readonly SurfaceInputEvidence[];
+    readonly sourceRoots: readonly SourceRootIdentity[];
+    readonly customSources: readonly CustomSourceIdentity[];
+    readonly adoptedSources: readonly AdoptedSourceIdentity[];
+    readonly nativeHookPolicySource?: Readonly<{
+        path: string;
+        sha256: string;
+        identity: FileIdentity;
+    }>;
+    readonly composeSources: readonly Readonly<{
+        path: string;
+        sha256: string;
+        identity: FileIdentity;
+    }>[];
+    readonly surfaceAssets: readonly SurfaceAssetIdentity[];
+    readonly warnings: readonly SurfaceGenerationWarning[];
+    readonly unapprovedMcpServers: readonly Readonly<{
+        name: string;
+        sources: readonly string[];
+        sha256: string;
+    }>[];
+    readonly registry: DerivedRegistry;
+    readonly siblingRoots: AuthenticatedSiblingRoots;
+    readonly workEnvironment: ConsumedWorkEnvironmentConfig;
+    readonly workApplication?: WorkApplicationAuthorityRecord;
+    readonly node: ResolvedExecutable;
+    readonly guardHandler?: GuardHandlerIdentity;
+    readonly openCodeGrantRoots: readonly Readonly<{
+        slug: string;
+        root: string;
+    }>[];
+    readonly now: string;
+    readonly producedAt: string;
+}
+interface AuthenticatedSiblingRoots {
+    readonly declaredRoot: string;
+    readonly canonicalRoot: string;
+    readonly rootIdentity: DirectoryIdentity;
+    readonly siblings: ReadonlyMap<string, Readonly<{
+        root: string;
+        identity: DirectoryIdentity;
+    }>>;
+}
+export declare function activeClaudeImports(bytes: string): readonly number[];
+export declare function siblingRootsCurrent(authority: AuthenticatedSiblingRoots): Promise<boolean>;
+export declare function authenticateSiblingRoots(root: string, config: DerivedRegistry['config'], configPath: string): Promise<Readonly<{
+    kind: 'complete';
+    roots: AuthenticatedSiblingRoots;
+}> | Readonly<{
+    kind: 'refusal';
+    reason: string;
+    code?: string;
+    target?: string;
+    fix?: string;
+}>>;
+export interface SourceRootIdentity {
+    readonly slug: string;
+    readonly root: string;
+    readonly identity: DirectoryIdentity;
+}
+export interface AdoptedSourceIdentity {
+    readonly path: string;
+    readonly sha256: string;
+    readonly identity: FileIdentity;
+}
+export interface CustomSourceIdentity {
+    readonly harness: string;
+    readonly feature: SurfaceFeature;
+    readonly path: string;
+    readonly sha256: string;
+    readonly identity: FileIdentity;
+    readonly maxBytes: number;
+}
+interface SurfaceAssetIdentity {
+    readonly path: SurfaceAssetPath;
+    readonly sha256: string;
+    readonly identity: FileIdentity;
+}
+interface CommandResult {
+    readonly action: 'sync' | 'check';
+    readonly dryRun: boolean;
+    readonly changes: readonly GeneratedEnvironmentChange[];
+    readonly generation: string;
+    readonly sourceSha256: string;
+    readonly paths: readonly string[];
+    readonly application: GeneratedApplicationProjection;
+    readonly staleRemoval?: GeneratedStaleRemovalApprovalRequest;
+}
+export interface GeneratedApplicationProjection {
+    readonly generatedPaths: readonly GeneratedPathFact[];
+    readonly sourceSha256: string;
+    /** The stack identity the generated files were rendered for; see `runtimeDeclarationSha256`. */
+    readonly runtimeSha256: string;
+    readonly generation: string;
+    readonly activeSurfaceOverrides: readonly ActiveSurfaceOverride[];
+    readonly changedOverrideOriginals: readonly SurfaceUpgradeFinding[];
+    readonly inspection: Readonly<{
+        readonly kind: 'passed';
+        readonly files: readonly Readonly<{
+            path: string;
+            sha256: string;
+            ownership: 'whole-file';
+        }>[];
+    }>;
+    readonly surfaceSelftest: GeneratedSurfaceSelftestProjection;
+}
+export interface WorkApplicationAuthoritiesProjection {
+    readonly kind: 'work-application-authorities';
+}
+export interface ConsumedWorkApplicationAuthorities {
+    readonly workEnvironment: ConsumedWorkEnvironmentConfig;
+    readonly evaluator: Readonly<{
+        readonly path: string;
+        readonly bytes: string;
+        readonly sha256: string;
+        readonly identity: FileIdentity;
+        readonly restriction: 'instructed';
+    }>;
+    readonly installedSkills: readonly Readonly<{
+        readonly path: string;
+        readonly sha256: string;
+    }>[];
+    readonly browser?: Readonly<{
+        readonly runtime: BrowserRuntimeProjection;
+        readonly namespace: StateNamespace;
+        readonly mcp: McpDeclaration;
+        readonly skillTemplate: Readonly<{
+            readonly path: string;
+            readonly bytes: string;
+            readonly sha256: string;
+            readonly identity: FileIdentity;
+        }>;
+    }>;
+    readonly testing: Readonly<{
+        readonly registry: GateRegistry;
+    }>;
+}
+export interface GeneratedCustomSurfaceSelftestInput {
+    readonly harness: string;
+    readonly feature: SurfaceFeature;
+    readonly state: 'enforced' | 'instructed';
+    readonly measuredOn: string;
+    readonly module: string;
+    readonly export: string;
+    readonly sourceSha256: string;
+    readonly resultSha256: string;
+    readonly sources: readonly Readonly<SurfaceSourceFile>[];
+    readonly evidence?: Readonly<{
+        reference: string;
+        sha256: string;
+    }>;
+}
+export interface GeneratedSurfaceSelftestProjection {
+    readonly schema: 'cockpit-generated-surface-selftest/v1';
+    readonly configuredHarnesses: readonly string[];
+    readonly declarations: DerivedRegistry['config']['surfaces']['harnesses'];
+    readonly entries: readonly SurfaceDesiredEntry[];
+    readonly custom: readonly GeneratedCustomSurfaceSelftestInput[];
+    readonly manifestSha256: string;
+}
+export interface GeneratedSurfaceHealthEvidence {
+    readonly observedAt: string;
+    readonly grants: readonly DirectoryGrant[];
+    readonly nativeGrants: NativeFragmentSet;
+    readonly guideCosts: readonly StandingCost[];
+    readonly skillCosts: readonly SkillStandingCost[];
+    readonly skillCollectionSha256: string;
+    readonly skillInventorySha256: string;
+    readonly skillInventory: readonly Readonly<{
+        target: string;
+        path: string;
+        sha256: string;
+    }>[];
+    readonly skills: readonly string[];
+}
+interface CompleteOutcome {
+    readonly kind: 'complete';
+    readonly artifact: null;
+    readonly destination: null;
+    readonly diagnostics: readonly Diagnostic[];
+    readonly result: CommandResult;
+    readonly status: 0;
+}
+export interface RefusalOutcome {
+    readonly kind: 'refusal';
+    readonly artifact: null;
+    readonly destination: null;
+    readonly diagnostics: readonly Diagnostic[];
+    readonly result: null;
+    readonly status: 2;
+}
+export type GeneratedEnvironmentCommandOutcome = (CompleteOutcome | RefusalOutcome) & Readonly<{
+    fixContext?: FixContext;
+    report?: Readonly<{
+        storedProducer: GeneratedProducer | null;
+        currentProducer: GeneratedEnvironmentCurrentness['currentProducer'];
+        repair: ReturnType<typeof proposeGeneratedEnvironmentRepair>;
+    }>;
+}>;
+export declare const defaultAdapters: GeneratedEnvironmentCommandAdapters;
+export declare const OWNERSHIP_PATH = ".cockpit/generated-environment-ownership.json";
+export declare const SHA256: RegExp;
+export declare const MAX_OWNERSHIP_BYTES = 1048576;
+export declare const COMPOSE_SOURCE_BYTES = 1048576;
+export declare const MAX_OWNED_FILES = 256;
+export declare const MAX_EXECUTABLE_BYTES = 536870912;
+export declare const MAX_GENERATED_BYTES = 16777216;
+export declare const MAX_SURFACE_FILE_BYTES = 65536;
+export declare const MAX_HELPER_FRAME_BYTES = 65536;
+export declare const HELPER_TIMEOUT_MS = 10000;
+export declare const NATIVE_HOOK_COST_TIMEOUT_MS = 60000;
+export declare const SURFACE_ROOT: string;
+export declare const RESTRICTION_ASSETS: readonly ["guards/bash-guard.sh", "guards/claude.adapter.json", "guards/codex.adapter.json", "guards/opencode.adapter.json"];
+export declare const REFERENCE_ASSETS: readonly ["references/test-data-and-personas.md"];
+export declare const WORK_ASSETS: readonly ["skills/cockpit-browser.skill.md", "references/browser.md", "references/testing-tiers.md"];
+export type SurfaceAssetPath = typeof RESTRICTION_ASSETS[number] | typeof EVALUATOR_ASSET | typeof SKILL_ASSETS[number] | typeof REFERENCE_ASSETS[number] | typeof WORK_ASSETS[number];
+interface GeneratedApplicationRecord {
+    readonly root: string;
+    readonly stackId: ReturnType<typeof stackId>;
+    readonly currentPublication: true | false;
+    readonly siblingRoots: AuthenticatedSiblingRoots;
+    readonly node: ResolvedExecutable;
+    readonly workApplication?: WorkApplicationAuthorityRecord;
+    readonly surfaceSelftest: GeneratedSurfaceSelftestProjection;
+    readonly surfaceHealth: GeneratedSurfaceHealthEvidence;
+}
+export type WorkApplicationAuthorityRecord = ConsumedWorkApplicationAuthorities;
+export declare const issuedApplicationProjections: WeakMap<object, GeneratedApplicationRecord>;
+export declare const projectedWorkApplicationAuthorities: WeakSet<object>;
+export declare const issuedWorkApplicationAuthorities: WeakMap<object, ConsumedWorkApplicationAuthorities>;
+export interface SelectedBootstrapRecord {
+    readonly root: string;
+    readonly rootIdentity: DirectoryIdentity;
+    readonly target: SurfaceTarget;
+    readonly node: ResolvedExecutable;
+    readonly assets: readonly SurfaceAssetIdentity[];
+    readonly inspected: InspectedBootstrapOutputs;
+    readonly result: SelectedBootstrapSurfaceResult;
+    readonly plan: PublicationPlan;
+    readonly adapters: GeneratedEnvironmentCommandAdapters;
+    readonly bootstrapState?: Readonly<{
+        address: BootstrapStateAddress;
+        record: BootstrapStateRecord;
+    }>;
+}
+export declare const issuedSelectedBootstrapAuthorities: WeakMap<object, SelectedBootstrapRecord>;
+export declare const consumedBootstrapStatePublications: WeakSet<object>;
+export declare function skillDescription(bytes: string): string | undefined;
+export declare const compareCodeUnits: (left: string, right: string) => number;
+export declare function sha256(value: string | Uint8Array): string;
+export declare function ownRecord(value: unknown): Record<string, unknown> | undefined;
+export declare function guideLines(bytes: string): number;
+export declare function guideCapExceeded(cost: Readonly<{
+    target: string;
+    value: number;
+    cap: number;
+}>): RefusalOutcome;
+export declare const CODEX_PROJECT_DOC_BYTES = 32768;
+export declare function guideBytesExceeded(bytes: number): RefusalOutcome;
+export declare function siblingGuideMissing(slug: string, guide: string, sourcePath: string): RefusalOutcome;
+export declare function overrideChangedRefusal(finding: SurfaceUpgradeFinding): RefusalOutcome;
+export declare function complete(action: CommandResult['action'], prepared: PreparedEnvironment, dryRun?: boolean, changes?: readonly GeneratedEnvironmentChange[], staleRemoval?: GeneratedStaleRemovalApprovalRequest): CompleteOutcome | RefusalOutcome;
+export declare function generatedPathFacts(prepared: PreparedEnvironment, applicability: 'declared-before-sync' | 'required-after-sync'): import("../../surfaces/ownership.js").GeneratedPathFactsResult;
+declare function isGeneratedApplicationSurfaceObservation(value: unknown): value is EnvironmentObservation;
+declare function generatedApplicationSurfaceObservationIssuedAt(value: unknown): number | undefined;
+export declare function confined(root: string, path: string): string | undefined;
+export declare function sourceIdentity(identity: FileIdentity): string;
+export declare function readSurfaceAsset(path: SurfaceAssetPath, read: AnchoredBatchReadResult): Readonly<{
+    path: SurfaceAssetPath;
+    bytes: string;
+    sha256: string;
+    identity: FileIdentity;
+}> | undefined;
+export declare function mergedAdapters(overrides: Partial<GeneratedEnvironmentCommandAdapters>): GeneratedEnvironmentCommandAdapters;
+export interface GeneratedEnvironmentRepairAuthority {
+    readonly kind: 'generated-environment-repair';
+}
+export interface GeneratedEnvironmentCurrentness {
+    readonly outcome: GeneratedEnvironmentCommandOutcome;
+    readonly changes: readonly GeneratedEnvironmentChange[];
+    readonly storedProducer: GeneratedProducer | null;
+    readonly currentProducer: Readonly<{
+        package: string;
+        version: string;
+        sourceRevision: string;
+    }>;
+    readonly fixContext: FixContext;
+    readonly repairAuthority?: GeneratedEnvironmentRepairAuthority;
+    readonly repairRefusal?: RefusalOutcome;
+}