@astrale-os/sdk 0.6.0-beta.2 → 0.6.0-beta.21

package/dist/tooling/cli/installation/reconcile.d.ts

@@ -1,32 +0,0 @@
-import type { InstallationTarget } from '../../../deployment/adapter/index.js';
-import type { Release } from '../../../deployment/release/index.js';
-import type { AstraleProcessResult } from '../astrale/process.js';
-export interface InstallationEvidence {
-    readonly status: 'unchanged' | 'installed' | 'upgraded';
-    readonly instance: string;
-    readonly origin: string;
-    readonly issuer: string;
-    readonly revision: string;
-    readonly generation: string;
-    readonly etag: string;
-}
-export type AstraleCommandResult = AstraleProcessResult;
-export interface InstallationDependencies {
-    run(input: {
-        readonly executable: string;
-        readonly args: readonly string[];
-        readonly projectDir: string;
-        readonly signal: AbortSignal;
-        readonly timeoutMs: number;
-    }): Promise<AstraleCommandResult>;
-}
-/** Reconcile one observed Release without ever replacing a different issuer. */
-export declare function reconcileInstallation(input: {
-    readonly projectDir: string;
-    readonly target: InstallationTarget;
-    readonly executable: string;
-    readonly identity?: string;
-    readonly credential?: string;
-    readonly release: Release;
-    readonly signal: AbortSignal;
-}, dependencies?: InstallationDependencies): Promise<InstallationEvidence>;

package/dist/tooling/cli/installation/reconcile.js

@@ -1,122 +0,0 @@
-import { astraleAuthorityArguments } from '../astrale/authority.js';
-import { AstraleCliError, isDomainNotInstalledFailure, astraleFailure } from '../astrale/failure.js';
-import { runAstrale } from '../astrale/process.js';
-import { canonicalIssuer, decodeInstallationObservation } from './observation.js';
-/** Reconcile one observed Release without ever replacing a different issuer. */
-export async function reconcileInstallation(input, dependencies = {
-    run: runAstrale,
-}) {
-    const origin = input.release.publication.origin;
-    const revision = input.release.publication.schema.revision;
-    const issuer = canonicalIssuer(input.release.addressing.issuer);
-    const etag = input.release.publication.etag;
-    const identity = input.identity ?? input.target.identity;
-    const authority = astraleAuthorityArguments({
-        ...(identity === undefined ? {} : { identity }),
-        ...(input.credential === undefined ? {} : { credential: input.credential }),
-    });
-    const executable = input.executable;
-    const before = await observe(input, origin, authority, executable, dependencies);
-    if (before !== undefined) {
-        assertIdentity(before, { origin, issuer });
-        if (before.revision === revision && before.etag === etag) {
-            return evidence('unchanged', input.target.instance, before);
-        }
-    }
-    let installationFailure;
-    try {
-        const installed = await dependencies.run({
-            executable,
-            projectDir: input.projectDir,
-            signal: input.signal,
-            timeoutMs: 250_000,
-            args: [
-                '--ci',
-                '--no-prompt',
-                'domain',
-                'install',
-                input.release.addressing.publicUrl,
-                '--direct',
-                '--allow-identity-override',
-                '-i',
-                input.target.instance,
-                '--json',
-                '--timeout',
-                '240000',
-                ...authority,
-            ],
-        });
-        if (installed.code !== 0)
-            installationFailure = astraleFailure('domain install', installed);
-    }
-    catch (cause) {
-        installationFailure = cause;
-    }
-    let after;
-    try {
-        after = await observe(input, origin, authority, executable, dependencies);
-    }
-    catch (cause) {
-        throw installationError(installationFailure === undefined ? [cause] : [installationFailure, cause], 'Domain installation outcome is unknown because reconciliation failed.');
-    }
-    if (installationFailure !== undefined && after === undefined) {
-        throw installationError([installationFailure], 'Domain installation failed and no installed Release was observed.');
-    }
-    if (after === undefined)
-        throw new TypeError('Installed Domain was absent after installation.');
-    try {
-        assertIdentity(after, { origin, issuer });
-        if (after.revision !== revision || after.etag !== etag) {
-            throw new TypeError('Installed Domain evidence differs from the deployed Release.');
-        }
-    }
-    catch (cause) {
-        if (installationFailure === undefined)
-            throw cause;
-        throw installationError([installationFailure, cause], 'Domain installation failed with a different observed Release.');
-    }
-    return evidence(before === undefined ? 'installed' : 'upgraded', input.target.instance, after);
-}
-function installationError(causes, message) {
-    const diagnostics = causes
-        .filter((cause) => cause instanceof AstraleCliError)
-        .map((cause) => cause.message);
-    return new AggregateError(causes, [message, ...diagnostics].join(' '));
-}
-async function observe(input, origin, authority, executable, dependencies) {
-    const result = await dependencies.run({
-        executable,
-        projectDir: input.projectDir,
-        signal: input.signal,
-        timeoutMs: 70_000,
-        args: [
-            '--ci',
-            '--no-prompt',
-            'introspect',
-            origin,
-            '-i',
-            input.target.instance,
-            '--json',
-            '--timeout',
-            '60000',
-            ...authority,
-        ],
-    });
-    if (result.code !== 0) {
-        if (isDomainNotInstalledFailure(result.stderr))
-            return undefined;
-        throw astraleFailure(`introspect ${origin}`, result);
-    }
-    return decodeInstallationObservation(result.stdout);
-}
-function assertIdentity(observed, expected) {
-    if (observed.origin !== expected.origin) {
-        throw new TypeError('Installed Domain evidence has a different origin.');
-    }
-    if (observed.issuer !== expected.issuer) {
-        throw new TypeError(`Installed Domain issuer ${observed.issuer} differs from deployment issuer ${expected.issuer}; refusing replacement.`);
-    }
-}
-function evidence(status, instance, observed) {
-    return Object.freeze({ status, instance, ...observed });
-}