@astrale-os/sdk 0.6.0-beta.13 → 0.6.0-beta.14

package/dist/tooling/cli/development/view.d.ts

@@ -1,28 +0,0 @@
-import type { Release } from '../../../deployment/release/legacy/index.js';
-import type { AstraleProcessResult } from '../astrale/process.js';
-export interface DevelopmentViewDependencies {
-    run(input: {
-        readonly executable: string;
-        readonly args: readonly string[];
-        readonly projectDir: string;
-        readonly signal: AbortSignal;
-        readonly timeoutMs: number;
-    }): Promise<AstraleProcessResult>;
-}
-/** Keep one browser tab alive across successful remote deployments. */
-export declare class DevelopmentView {
-    #private;
-    constructor(input: {
-        readonly executable: string;
-        readonly projectDir: string;
-        readonly instance: string;
-        readonly identity?: string;
-        readonly credential?: string;
-        readonly dependencies?: DevelopmentViewDependencies;
-    });
-    /** Require in-place refresh before publishing anything that depends on this CLI feature. */
-    prepare(signal: AbortSignal): Promise<void>;
-    /** Called after each committed deployment; the development loop owns candidate deduplication. */
-    refresh(release: Release, signal: AbortSignal): Promise<string | undefined>;
-    close(signal: AbortSignal): Promise<void>;
-}

package/dist/tooling/cli/development/view.js

@@ -1,151 +0,0 @@
-import { astraleAuthorityArguments } from '../astrale/authority.js';
-import { runAstrale } from '../astrale/process.js';
-/** Keep one browser tab alive across successful remote deployments. */
-export class DevelopmentView {
-    #executable;
-    #projectDir;
-    #instance;
-    #authority;
-    #dependencies;
-    #current;
-    #prepared = false;
-    constructor(input) {
-        this.#executable = input.executable;
-        this.#projectDir = input.projectDir;
-        this.#instance = input.instance;
-        this.#authority = astraleAuthorityArguments({
-            ...(input.identity === undefined ? {} : { identity: input.identity }),
-            ...(input.credential === undefined ? {} : { credential: input.credential }),
-        });
-        this.#dependencies = input.dependencies ?? { run: runAstrale };
-    }
-    /** Require in-place refresh before publishing anything that depends on this CLI feature. */
-    async prepare(signal) {
-        if (this.#prepared)
-            return;
-        const result = await this.#dependencies.run({
-            executable: this.#executable,
-            projectDir: this.#projectDir,
-            signal,
-            timeoutMs: 10_000,
-            args: ['view', '--help'],
-        });
-        if (result.code !== 0 || !result.stdout.includes('--refresh <id>')) {
-            throw new Error('This Astrale CLI cannot refresh development Views. Run astrale update before pnpm dev.');
-        }
-        this.#prepared = true;
-    }
-    /** Called after each committed deployment; the development loop owns candidate deduplication. */
-    async refresh(release, signal) {
-        const frontend = release.build.frontend;
-        if (frontend === undefined) {
-            await this.close(AbortSignal.timeout(30_000));
-            return undefined;
-        }
-        const path = `/:${frontend.entrypoint.origin}:view.${frontend.entrypoint.name}`;
-        const previous = this.#current;
-        if (previous?.path === path) {
-            const refreshed = await this.#dependencies.run({
-                executable: this.#executable,
-                projectDir: this.#projectDir,
-                signal,
-                timeoutMs: 60_000,
-                args: ['--ci', '--no-prompt', 'view', '--refresh', previous.id, '--json'],
-            });
-            if (refreshed.code !== 0)
-                throw new Error('Astrale CLI could not refresh the development View.');
-            return previous.pageUrl;
-        }
-        const next = await this.#open(path, signal);
-        if (previous !== undefined) {
-            try {
-                await this.#close(previous.id, AbortSignal.timeout(30_000));
-            }
-            catch (cause) {
-                try {
-                    await this.#close(next.id, AbortSignal.timeout(30_000));
-                }
-                catch (rollback) {
-                    throw new AggregateError([cause, rollback], 'Astrale View replacement and rollback cleanup failed.');
-                }
-                throw cause;
-            }
-        }
-        this.#current = next;
-        return next.pageUrl;
-    }
-    async close(signal) {
-        const current = this.#current;
-        if (current === undefined)
-            return;
-        await this.#close(current.id, signal);
-        if (this.#current === current) {
-            this.#current = undefined;
-        }
-    }
-    async #open(path, signal) {
-        const result = await this.#dependencies.run({
-            executable: this.#executable,
-            projectDir: this.#projectDir,
-            signal,
-            timeoutMs: 60_000,
-            args: [
-                '--ci',
-                '--no-prompt',
-                'view',
-                path,
-                '--browser',
-                '--instance',
-                this.#instance,
-                '--json',
-                ...this.#authority,
-            ],
-        });
-        if (result.code !== 0)
-            throw new Error('Astrale CLI could not open the development View.');
-        return { ...decodeOpenedView(result.stdout), path };
-    }
-    async #close(id, signal) {
-        const result = await this.#dependencies.run({
-            executable: this.#executable,
-            projectDir: this.#projectDir,
-            signal,
-            timeoutMs: 30_000,
-            args: ['--ci', '--no-prompt', 'view', '--close', id, '--json'],
-        });
-        if (result.code !== 0)
-            throw new Error('Astrale CLI could not close the development View.');
-    }
-}
-function decodeOpenedView(input) {
-    let value;
-    try {
-        value = JSON.parse(input);
-    }
-    catch (cause) {
-        throw new TypeError('Astrale View output is invalid.', { cause });
-    }
-    const session = record(value) ? value.session : undefined;
-    const id = record(session) ? session.id : undefined;
-    const pageUrl = record(session) ? session.pageUrl : undefined;
-    if (typeof id !== 'string' || id.length === 0 || !webUrl(pageUrl)) {
-        throw new TypeError('Astrale View output is invalid.');
-    }
-    return Object.freeze({ id, pageUrl });
-}
-function webUrl(input) {
-    if (typeof input !== 'string' || input.length === 0 || input.length > 2_048)
-        return false;
-    try {
-        const value = new URL(input);
-        return ((value.protocol === 'http:' || value.protocol === 'https:') &&
-            value.username === '' &&
-            value.password === '');
-    }
-    catch {
-        return false;
-    }
-}
-function record(input) {
-    return input !== null && typeof input === 'object' && !Array.isArray(input);
-}

package/dist/tooling/cli/environment-release.d.ts

@@ -1,24 +0,0 @@
-import type { InstallationTarget, ReadyDeployResult } from '../../deployment/adapter/index.js';
-import type { InstallationEvidence } from './installation/index.js';
-import { writeDeploymentEvidence } from './evidence.js';
-import { reconcileInstallation } from './installation/index.js';
-export interface EnvironmentReleaseDependencies {
-    readonly writeEvidence: typeof writeDeploymentEvidence;
-    readonly reconcileInstallation: typeof reconcileInstallation;
-}
-/** Retain verified provider evidence and reconcile one optional durable Kernel installation. */
-export declare function reconcileEnvironmentRelease(input: {
-    readonly projectDir: string;
-    readonly environment: string;
-    readonly adapter: {
-        readonly name: string;
-        readonly version: string;
-    };
-    readonly deployment: ReadyDeployResult;
-    readonly installation?: InstallationTarget;
-    readonly deployOnly: boolean;
-    readonly identity?: string;
-    readonly credential?: string;
-    readonly installationExecutable?: string;
-    readonly signal: AbortSignal;
-}, dependencies?: EnvironmentReleaseDependencies): Promise<InstallationEvidence | undefined>;

package/dist/tooling/cli/environment-release.js

@@ -1,46 +0,0 @@
-import { writeDeploymentEvidence } from './evidence.js';
-import { reconcileInstallation } from './installation/index.js';
-/** Retain verified provider evidence and reconcile one optional durable Kernel installation. */
-export async function reconcileEnvironmentRelease(input, dependencies = {
-    writeEvidence: writeDeploymentEvidence,
-    reconcileInstallation,
-}) {
-    try {
-        await dependencies.writeEvidence({
-            projectDir: input.projectDir,
-            environment: input.environment,
-            adapter: input.adapter,
-            deployment: input.deployment,
-        });
-    }
-    catch (cause) {
-        throw new TypeError(`Domain ${input.deployment.release.publication.origin} remains deployed, but its local evidence could not be saved. Kernel installation was not attempted.`, { cause });
-    }
-    if (input.installation === undefined || input.deployOnly)
-        return undefined;
-    if (input.installationExecutable === undefined) {
-        throw new TypeError('A compatible Astrale CLI must be pinned before deploying an installed Environment.');
-    }
-    const installation = await dependencies.reconcileInstallation({
-        projectDir: input.projectDir,
-        target: input.installation,
-        executable: input.installationExecutable,
-        ...(input.identity === undefined ? {} : { identity: input.identity }),
-        ...(input.credential === undefined ? {} : { credential: input.credential }),
-        release: input.deployment.release,
-        signal: input.signal,
-    });
-    try {
-        await dependencies.writeEvidence({
-            projectDir: input.projectDir,
-            environment: input.environment,
-            adapter: input.adapter,
-            deployment: input.deployment,
-            installation,
-        });
-    }
-    catch (cause) {
-        throw new TypeError(`Domain ${installation.origin} remains installed on ${installation.instance}, but its local evidence could not be saved. The installation was not rolled back.`, { cause });
-    }
-    return installation;
-}

package/dist/tooling/cli/evidence.d.ts

@@ -1,14 +0,0 @@
-import type { ReadyDeployResult } from '../../deployment/adapter/index.js';
-import type { InstallationEvidence } from './installation/index.js';
-export declare const DEPLOYMENT_EVIDENCE_VERSION: 1;
-/** Persist one non-secret, non-authoritative continuity observation atomically. */
-export declare function writeDeploymentEvidence(input: {
-    readonly projectDir: string;
-    readonly environment: string;
-    readonly adapter: {
-        readonly name: string;
-        readonly version: string;
-    };
-    readonly deployment: ReadyDeployResult;
-    readonly installation?: InstallationEvidence;
-}): Promise<string>;

package/dist/tooling/cli/evidence.js

@@ -1,53 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { mkdir, rename, unlink, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-export const DEPLOYMENT_EVIDENCE_VERSION = 1;
-/** Persist one non-secret, non-authoritative continuity observation atomically. */
-export async function writeDeploymentEvidence(input) {
-    const directory = join(input.projectDir, '.astrale', 'environments', input.environment);
-    const path = join(directory, 'deployment.json');
-    await mkdir(directory, { recursive: true });
-    const provider = input.deployment.progress.provider.evidence;
-    const value = Object.freeze({
-        version: DEPLOYMENT_EVIDENCE_VERSION,
-        environment: input.environment,
-        adapter: Object.freeze({ name: input.adapter.name, version: input.adapter.version }),
-        deployment: Object.freeze({
-            provider: provider.provider,
-            id: provider.deployment,
-            artifact: provider.artifact,
-            issuer: input.deployment.release.addressing.issuer,
-            publicUrl: input.deployment.release.addressing.publicUrl,
-            origin: input.deployment.release.publication.origin,
-            revision: input.deployment.release.publication.schema.revision,
-            etag: input.deployment.release.publication.etag,
-            readiness: 'ready',
-            ...(provider.preflight === undefined ? {} : { preflight: provider.preflight }),
-        }),
-        ...(input.installation === undefined
-            ? {}
-            : {
-                installation: Object.freeze({
-                    instance: input.installation.instance,
-                    origin: input.installation.origin,
-                    issuer: input.installation.issuer,
-                    revision: input.installation.revision,
-                    etag: input.installation.etag,
-                    generation: input.installation.generation,
-                    status: input.installation.status,
-                }),
-            }),
-    });
-    const staging = join(directory, `.deployment-${randomUUID()}.json`);
-    await writeFile(staging, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600, flag: 'wx' });
-    try {
-        await rename(staging, path);
-    }
-    finally {
-        await unlink(staging).catch((cause) => {
-            if (cause.code !== 'ENOENT')
-                throw cause;
-        });
-    }
-    return path;
-}

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

@@ -1,2 +0,0 @@
-export { reconcileInstallation } from './reconcile.js';
-export type { AstraleCommandResult, InstallationDependencies, InstallationEvidence, } from './reconcile.js';

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

@@ -1 +0,0 @@
-export { reconcileInstallation } from './reconcile.js';

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

@@ -1,10 +0,0 @@
-export interface InstallationObservation {
-    readonly origin: string;
-    readonly revision: string;
-    readonly issuer: string;
-    readonly generation: string;
-    readonly etag: string;
-}
-/** Admit exact installed Release evidence returned by Kernel introspection. */
-export declare function decodeInstallationObservation(input: string): InstallationObservation;
-export declare function canonicalIssuer(input: string): string;

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

@@ -1,44 +0,0 @@
-/** Admit exact installed Release evidence returned by Kernel introspection. */
-export function decodeInstallationObservation(input) {
-    let decoded;
-    try {
-        decoded = JSON.parse(input);
-    }
-    catch (cause) {
-        throw new TypeError('Astrale introspection did not return one JSON value.', { cause });
-    }
-    const root = record(decoded);
-    const publication = record(root.publication);
-    const identity = record(publication.identity);
-    if (typeof root.origin !== 'string' ||
-        typeof root.revision !== 'string' ||
-        typeof root.generation !== 'string' ||
-        !/^sha256:[0-9a-f]{64}$/u.test(root.generation) ||
-        publication.origin !== root.origin ||
-        publication.revision !== root.revision ||
-        typeof identity.issuer !== 'string' ||
-        typeof publication.etag !== 'string' ||
-        !/^sha256:[0-9a-f]{64}$/u.test(publication.etag)) {
-        throw new TypeError('Astrale introspection returned invalid installed Domain evidence.');
-    }
-    return Object.freeze({
-        origin: root.origin,
-        revision: root.revision,
-        issuer: canonicalIssuer(identity.issuer),
-        generation: root.generation,
-        etag: publication.etag,
-    });
-}
-export function canonicalIssuer(input) {
-    const url = new URL(input);
-    if (url.href !== url.origin && url.href !== `${url.origin}/`) {
-        throw new TypeError('Release issuer must be one canonical origin.');
-    }
-    return url.origin;
-}
-function record(input) {
-    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
-        throw new TypeError('Astrale introspection returned invalid installed Domain evidence.');
-    }
-    return input;
-}

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/legacy/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 });
-}