@rehearsal-db/core 0.1.0-beta.13 → 0.1.0-beta.15

package/dist/src/cli/runtime_commands.d.mts

@@ -0,0 +1,265 @@
+/**
+ * CLI orchestration for one or more isolated database runtimes and their
+ * project-owned proof commands.
+ */
+import { holdApplicationSession } from "../application/session.mjs";
+import type { RehearsalConfigPathOptions } from "../project/configuration.mjs";
+import { buildRehearsalPlan } from "../runtime/plan.mjs";
+import { loadRuntimeTopology } from "../runtime/topology.mjs";
+import type { RuntimeTopologyTarget } from "../runtime/topology.mjs";
+import type { InstalledPackageFingerprint } from "../shared/operation_guard.mjs";
+import type { RehearsalCliFlags } from "./arguments.mjs";
+import type { RehearsalErrorCategory } from "../shared/diagnostics.mjs";
+type RuntimeTopology = Awaited<ReturnType<typeof loadRuntimeTopology>>;
+type RuntimeAction = "run" | "start" | "migrate" | "reset" | "status" | "stop" | "discard" | "verify";
+interface ManagerReceipt {
+    readonly action: RuntimeAction;
+    readonly target: string;
+    readonly durationMs: number;
+    readonly output: string;
+}
+interface RuntimeStackResult {
+    readonly topology: RuntimeTopology;
+    readonly runtime: ManagerReceipt | Readonly<{
+        action: RuntimeAction;
+        durationMs: number;
+        output: string;
+        targets: readonly ManagerReceipt[];
+    }>;
+}
+export declare const buildRuntimeStackPlan: (planOptions: RehearsalConfigPathOptions) => Promise<{
+    config: {
+        schemaVersion: 1;
+        path: string;
+        project: string;
+    };
+    environment: {
+        target: "postgresql" | "supabase";
+        kind: string;
+        applicationUrl: string;
+        projectId: string;
+        ports: Readonly<{
+            api?: number;
+            database: number;
+            studio?: number;
+        }>;
+        hostedAccess: "disabled";
+        outboundNetwork: "deny";
+        authenticationProviders: readonly string[];
+        authenticationCallback: string | null;
+        barriers: string[];
+    };
+    baseline: {
+        rehearsalVersion: string;
+        formatVersion: 1 | 2;
+        generationId: string;
+        createdAt: string | null;
+        migrationCutoff: string;
+        migrationHistorySha256: string;
+        sanitizationPolicySha256: string;
+        dataSha256: string;
+        tableCount: number;
+        rowCount: number;
+        migrationCount: number;
+        verification: string;
+    };
+    migrations: {
+        representedCount: number;
+        candidateCount: number;
+        candidateSha256: string;
+        candidates: {
+            filename: string;
+            sha256: string;
+        }[];
+    };
+    execution: string[];
+    guarantee: string;
+    paths: {
+        artifactDirectory: string;
+        migrationDirectory: string;
+        sanitizationPolicy: string;
+    };
+} | {
+    targets: {
+        name: string;
+        declaration: RuntimeTopologyTarget["declaration"];
+        plan: Awaited<ReturnType<typeof buildRehearsalPlan>>;
+    }[];
+    migrations: {
+        candidateCount: number;
+        candidateSha256: string;
+    };
+    execution: string[];
+    guarantee: string;
+}>;
+export declare const runRuntimeStackDoctor: (planOptions: RehearsalConfigPathOptions) => Promise<{
+    state: string;
+    checks: {
+        id: string;
+        label: string;
+        status: string;
+        detail: string;
+        remediation: string;
+    }[];
+    ambientHostedVariables?: never;
+} | {
+    state: string;
+    checks: ({
+        status: string;
+        detail: unknown;
+        durationMs: number;
+        remediation?: never;
+        id: string;
+        label: string;
+    } | {
+        status: string;
+        detail: string;
+        remediation: string;
+        durationMs: number;
+        id: string;
+        label: string;
+    } | {
+        status: string;
+        detail: string;
+        remediation: string;
+        id: string;
+        label: string;
+    })[];
+    ambientHostedVariables: {
+        presentButQuarantined: string[];
+        note: string;
+    };
+}>;
+export declare const topologyCandidateSummary: (planOptions: RehearsalConfigPathOptions) => Promise<{
+    baselineGenerationId: string;
+    candidateSha256: string;
+    candidateCount: number;
+    candidates: {
+        version: string;
+        name: string;
+        filename: string;
+        sha256: string;
+        status: string;
+        target: string;
+    }[];
+    targets: {
+        name: string;
+        configPath: string;
+        baselineGenerationId: string;
+        candidateSha256: string;
+        candidateCount: number;
+        candidates: readonly {
+            version: string;
+            name: string;
+            filename: string;
+            sha256: string;
+            status: string;
+        }[];
+    }[];
+    topology: Readonly<{
+        projectRoot: string;
+        primary: RuntimeTopologyTarget;
+        dependents: readonly RuntimeTopologyTarget[];
+        targets: readonly RuntimeTopologyTarget[];
+    }>;
+}>;
+export declare const classifyManagerFailure: ({ action, output, inferredCategory, }: {
+    action: RuntimeAction;
+    output: string;
+    inferredCategory: RehearsalErrorCategory;
+}) => RehearsalErrorCategory;
+export declare const parseDockerCapacity: (output: string) => {
+    cpus: number;
+    memoryBytes: number;
+    runningContainers: number;
+    containers: number;
+} | null;
+export declare const parseColimaMemory: (output: string) => {
+    totalBytes: number;
+    availableBytes: number;
+} | null;
+export declare const topologyCommandEnvironment: (topology: RuntimeTopology) => NodeJS.ProcessEnv;
+export declare const topologyEnvironmentFiles: (topology: RuntimeTopology) => Readonly<Record<string, string>> & {
+    readonly primary: string;
+};
+export declare const createRuntimeCommands: ({ packageRoot, projectRoot, managerPath, getActivePackageFingerprint, }: {
+    packageRoot: string;
+    projectRoot: string;
+    managerPath: string;
+    getActivePackageFingerprint: () => InstalledPackageFingerprint | undefined;
+}) => {
+    openRuntimeApplication: ({ flags, planOptions, onReady, }: {
+        flags: RehearsalCliFlags;
+        planOptions: RehearsalConfigPathOptions;
+        onReady?: Parameters<typeof holdApplicationSession>[0]["onReady"];
+    }) => Promise<{
+        action: string;
+        started: ManagerReceipt | Readonly<{
+            action: RuntimeAction;
+            durationMs: number;
+            output: string;
+            targets: readonly ManagerReceipt[];
+        }>;
+        verified: ManagerReceipt | Readonly<{
+            action: RuntimeAction;
+            durationMs: number;
+            output: string;
+            targets: readonly ManagerReceipt[];
+        }>;
+        preparations: {
+            command: string;
+            output: string;
+            target: string;
+        }[];
+        application: {
+            command: string;
+            readiness: Readonly<{
+                url: string;
+                status: number;
+            }>;
+            stoppedBy: string;
+            diagnostics: import("../application/session.mjs").ApplicationDiagnostics;
+        };
+    }>;
+    prepareCandidateConfirmation: ({ command, flags, planOptions, }: {
+        command: RuntimeAction;
+        flags: RehearsalCliFlags;
+        planOptions: RehearsalConfigPathOptions;
+    }) => Promise<boolean>;
+    prepareDependentTargets: ({ topology, environment, }: {
+        topology: RuntimeTopology;
+        environment: NodeJS.ProcessEnv;
+    }) => {
+        command: string;
+        output: string;
+        target: string;
+    }[];
+    proveRuntimeStack: ({ topology, planOptions, environment, }: {
+        topology: RuntimeTopology;
+        planOptions: RehearsalConfigPathOptions;
+        environment: NodeJS.ProcessEnv;
+    }) => Promise<{
+        applicationProof: {
+            command: string;
+            output: string;
+        };
+        dependentProofs: {
+            target: string;
+            command: string;
+            output: string;
+        }[];
+    }>;
+    runManager: ({ action, flags, configPath, confirmation, targetName, }: {
+        action: RuntimeAction;
+        flags: RehearsalCliFlags;
+        configPath?: string;
+        confirmation?: string;
+        targetName?: string;
+    }) => ManagerReceipt;
+    runRuntimeStack: ({ command, flags, planOptions, }: {
+        command: RuntimeAction;
+        flags: RehearsalCliFlags;
+        planOptions: RehearsalConfigPathOptions;
+    }) => Promise<RuntimeStackResult>;
+};
+export {};