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

package/dist/deployment/verify/readiness/publication.js

@@ -1,41 +0,0 @@
-import * as publication from '@astrale-os/kernel-protocol/release/legacy';
-const MAXIMUM_PUBLICATION_BYTES = 1024 * 1024;
-const MAXIMUM_BUNDLE_BYTES = 16 * 1024 * 1024;
-/** Fetch and verify the exact live Publication and Bundle for one Release. */
-export async function verifyPublication(release, options = {}) {
-    const fetcher = options.fetch ?? globalThis.fetch;
-    const publicationUrl = publication.url(release.addressing.publicUrl);
-    const response = await fetchRequired(fetcher, publicationUrl, options.signal);
-    const deployed = publication.accept(JSON.parse(await text(response, publicationUrl, MAXIMUM_PUBLICATION_BYTES)));
-    if (!publication.matchesReference(deployed, publication.reference(release.publication))) {
-        throw new Error('Live Publication differs from the expected Release.');
-    }
-    const bundleResponse = await fetchRequired(fetcher, deployed.schema.bundle.href, options.signal);
-    const bytes = new Uint8Array(await bounded(bundleResponse, deployed.schema.bundle.href, MAXIMUM_BUNDLE_BYTES));
-    publication.decodeBundle(deployed, bytes);
-    return deployed;
-}
-async function fetchRequired(fetcher, url, signal) {
-    const response = await fetcher(url, {
-        redirect: 'error',
-        ...(signal === undefined ? {} : { signal }),
-    });
-    if (!response.ok)
-        throw new Error(`GET ${url} returned ${response.status}.`);
-    return response;
-}
-async function bounded(response, url, maximum) {
-    const bytes = await response.arrayBuffer();
-    if (bytes.byteLength > maximum)
-        throw new Error(`GET ${url} exceeded ${maximum} bytes.`);
-    return bytes;
-}
-async function text(response, url, maximum) {
-    const bytes = await bounded(response, url, maximum);
-    try {
-        return new TextDecoder('utf-8', { fatal: true, ignoreBOM: false }).decode(bytes);
-    }
-    catch (cause) {
-        throw new Error(`GET ${url} returned invalid UTF-8.`, { cause });
-    }
-}

package/dist/execution/service/publication/delivery.d.ts

@@ -1,2 +0,0 @@
-import type { publication } from '@astrale-os/kernel-server';
-export declare function delivery(input: publication.delivery.Provider | undefined): publication.delivery.Provider | undefined;

package/dist/execution/service/publication/installation.d.ts

@@ -1,3 +0,0 @@
-import type { publication } from '@astrale-os/kernel-server';
-import type { Release } from '../../../deployment/release/legacy/index.js';
-export declare function installation(release: Release, provider: publication.delivery.Provider | undefined): void;

package/dist/execution/service/publication/installation.js

@@ -1,8 +0,0 @@
-export function installation(release, provider) {
-    const advertised = release.publication.delivery !== undefined;
-    if (advertised !== (provider !== undefined)) {
-        throw new TypeError(advertised
-            ? 'Release advertises Publication delivery without a Provider.'
-            : 'Publication delivery Provider has no Release endpoint.');
-    }
-}

package/dist/execution/service/publication/source.d.ts

@@ -1,3 +0,0 @@
-import type { PublicationSource } from '@astrale-os/kernel-server';
-import type { LoadedRuntime } from '../../runtime/index.js';
-export declare function source(runtime: LoadedRuntime): PublicationSource;

package/dist/execution/service/publication/source.js

@@ -1,11 +0,0 @@
-import { preparePublicationSnapshot } from '@astrale-os/kernel-server';
-export function source(runtime) {
-    const release = runtime.release;
-    const snapshot = preparePublicationSnapshot({
-        publication: release.publication,
-        bundle: release.build.schema.bundle.bytes(),
-        table: release.routes,
-        domain: runtime.domain,
-    });
-    return Object.freeze({ current: () => snapshot });
-}

package/dist/tooling/cli/astrale/authority.d.ts

@@ -1,5 +0,0 @@
-/** Build one mutually exclusive authority argument set for an Astrale CLI operation. */
-export declare function astraleAuthorityArguments(input: {
-    readonly identity?: string;
-    readonly credential?: string;
-}): readonly string[];

package/dist/tooling/cli/astrale/authority.js

@@ -1,11 +0,0 @@
-/** Build one mutually exclusive authority argument set for an Astrale CLI operation. */
-export function astraleAuthorityArguments(input) {
-    if (input.identity !== undefined && input.credential !== undefined) {
-        throw new TypeError('Astrale authority cannot combine an identity and a credential.');
-    }
-    return input.credential === undefined
-        ? input.identity === undefined
-            ? Object.freeze([])
-            : Object.freeze(['--as', input.identity])
-        : Object.freeze(['--creds', input.credential]);
-}

package/dist/tooling/cli/astrale/executable.d.ts

@@ -1,2 +0,0 @@
-/** Resolve one exact executable for a complete sequence of Kernel CLI operations. */
-export declare function resolveAstraleExecutable(input?: string): Promise<string>;

package/dist/tooling/cli/astrale/executable.js

@@ -1,47 +0,0 @@
-import { constants } from 'node:fs';
-import { access, readFile, realpath } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { delimiter, isAbsolute, join } from 'node:path';
-/** Resolve one exact executable for a complete sequence of Kernel CLI operations. */
-export async function resolveAstraleExecutable(input = 'astrale') {
-    const candidates = isAbsolute(input) ? [input] : await executableCandidates(input);
-    for (const candidate of candidates) {
-        try {
-            await access(candidate, constants.X_OK);
-            return await realpath(candidate);
-        }
-        catch {
-            // Continue through the bounded recorded-install and PATH candidates.
-        }
-    }
-    throw new TypeError('Astrale CLI is unavailable. Install it with the official Astrale installer.');
-}
-async function executableCandidates(input) {
-    const path = (process.env.PATH ?? '')
-        .split(delimiter)
-        .filter(Boolean)
-        .map((directory) => join(directory, input));
-    if (input !== 'astrale')
-        return path;
-    const installed = await recordedInstallation();
-    return installed === undefined ? path : [installed, ...path];
-}
-async function recordedInstallation() {
-    const home = process.env.ASTRALE_HOME ?? join(homedir(), '.astrale');
-    try {
-        const decoded = JSON.parse(await readFile(join(home, 'install.json'), 'utf8'));
-        if (typeof decoded !== 'object' ||
-            decoded === null ||
-            !('method' in decoded) ||
-            decoded.method !== 'script' ||
-            !('bin' in decoded) ||
-            typeof decoded.bin !== 'string' ||
-            !isAbsolute(decoded.bin)) {
-            return undefined;
-        }
-        return decoded.bin;
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/tooling/cli/astrale/failure.d.ts

@@ -1,6 +0,0 @@
-import type { AstraleProcessResult } from './process.js';
-/** Only sanitized CLI diagnostics may be promoted through installation failures. */
-export declare class AstraleCliError extends Error {
-}
-export declare function astraleFailure(command: string, result: AstraleProcessResult): Error;
-export declare function isDomainNotInstalledFailure(stderr: string): boolean;

package/dist/tooling/cli/astrale/failure.js

@@ -1,48 +0,0 @@
-/** Only sanitized CLI diagnostics may be promoted through installation failures. */
-export class AstraleCliError extends Error {
-}
-export function astraleFailure(command, result) {
-    let diagnostic;
-    try {
-        const failure = record(JSON.parse(result.stderr));
-        const error = admittedCode(failure.error);
-        const reason = recordOrUndefined(failure.reason);
-        const reasonCode = admittedCode(reason?.code);
-        diagnostic =
-            error === undefined ? undefined : reasonCode === undefined ? error : `${error}/${reasonCode}`;
-    }
-    catch {
-        // Never forward raw stderr because a credential-bearing command owns it.
-    }
-    return new AstraleCliError(`Astrale CLI ${command} failed${diagnostic === undefined ? '' : ` (${diagnostic})`}.`);
-}
-function admittedCode(input) {
-    return typeof input === 'string' && /^[A-Z][A-Z0-9_]{0,63}$/u.test(input) ? input : undefined;
-}
-function recordOrUndefined(input) {
-    return input !== null && typeof input === 'object' && !Array.isArray(input)
-        ? input
-        : undefined;
-}
-export function isDomainNotInstalledFailure(stderr) {
-    try {
-        const failure = record(JSON.parse(stderr));
-        if (failure.error === 'DOMAIN_NOT_INSTALLED')
-            return true;
-        const reason = failure.reason;
-        return (failure.error === 'RESPONSE_ERROR' &&
-            reason !== null &&
-            typeof reason === 'object' &&
-            !Array.isArray(reason) &&
-            Reflect.get(reason, 'code') === 'SCHEMA_NOT_FOUND');
-    }
-    catch {
-        return false;
-    }
-}
-function record(input) {
-    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
-        throw new TypeError('Expected an object response.');
-    }
-    return input;
-}

package/dist/tooling/cli/astrale/instance.d.ts

@@ -1,11 +0,0 @@
-import { runAstrale } from './process.js';
-/** Resolve and probe a bookmark through the pinned CLI, preserving its TLS trust. */
-export declare function resolveAstraleInstanceIssuer(input: {
-    readonly executable: string;
-    readonly projectDir: string;
-    readonly instance: string;
-    readonly expectedIssuer?: string;
-    readonly signal: AbortSignal;
-}, dependencies?: {
-    readonly run: typeof runAstrale;
-}): Promise<string>;

package/dist/tooling/cli/astrale/instance.js

@@ -1,52 +0,0 @@
-import { astraleFailure } from './failure.js';
-import { runAstrale } from './process.js';
-/** Resolve and probe a bookmark through the pinned CLI, preserving its TLS trust. */
-export async function resolveAstraleInstanceIssuer(input, dependencies = { run: runAstrale }) {
-    const result = await dependencies.run({
-        executable: input.executable,
-        projectDir: input.projectDir,
-        signal: input.signal,
-        timeoutMs: 30_000,
-        args: ['--ci', '--no-prompt', 'instance', 'status', input.instance, '--bookmarked', '--json'],
-    });
-    if (result.code !== 0)
-        throw astraleFailure('instance status', result);
-    let value;
-    try {
-        value = JSON.parse(result.stdout);
-    }
-    catch {
-        throw new TypeError('Astrale instance status did not return one JSON value.');
-    }
-    if (value === null ||
-        typeof value !== 'object' ||
-        Array.isArray(value) ||
-        !('kind' in value) ||
-        value.kind !== 'bookmark' ||
-        !('state' in value) ||
-        value.state !== 'ready' ||
-        !('issuer' in value) ||
-        typeof value.issuer !== 'string') {
-        throw new TypeError('Astrale instance status returned invalid Kernel identity evidence.');
-    }
-    let issuer;
-    try {
-        issuer = new URL(value.issuer);
-    }
-    catch {
-        throw new TypeError('Astrale instance status returned an invalid Kernel issuer.');
-    }
-    if (!['https:', 'http:'].includes(issuer.protocol) ||
-        issuer.username ||
-        issuer.password ||
-        issuer.search ||
-        issuer.hash) {
-        throw new TypeError('Astrale instance status returned an invalid Kernel issuer.');
-    }
-    // Child Kernels share an origin, but their path-qualified identities remain distinct.
-    const canonical = issuer.href.replace(/\/$/u, '');
-    if (input.expectedIssuer !== undefined && canonical !== input.expectedIssuer) {
-        throw new Error('Installation bookmark changed Kernel; restart pnpm dev to apply it.');
-    }
-    return canonical;
-}

package/dist/tooling/cli/astrale/process.d.ts

@@ -1,13 +0,0 @@
-export interface AstraleProcessResult {
-    readonly code: number;
-    readonly stdout: string;
-    readonly stderr: string;
-}
-/** Run one exact Kernel CLI executable with bounded output, time, and termination. */
-export declare function runAstrale(input: {
-    readonly executable: string;
-    readonly args: readonly string[];
-    readonly projectDir: string;
-    readonly signal: AbortSignal;
-    readonly timeoutMs: number;
-}): Promise<AstraleProcessResult>;

package/dist/tooling/cli/astrale/process.js

@@ -1,94 +0,0 @@
-import { spawn } from 'node:child_process';
-const OUTPUT_LIMIT = 256 * 1024;
-const TERMINATION_GRACE_MS = 1_000;
-/** Run one exact Kernel CLI executable with bounded output, time, and termination. */
-export function runAstrale(input) {
-    if (input.signal.aborted)
-        return Promise.reject(abortError(input.signal));
-    return new Promise((resolve, reject) => {
-        let child;
-        try {
-            child = spawn(input.executable, [...input.args], {
-                cwd: input.projectDir,
-                stdio: ['pipe', 'pipe', 'pipe'],
-                shell: false,
-                // This owner already forwards cancellation and enforces a deadline. Keep
-                // terminal group signals from killing installation observation/View cleanup.
-                detached: process.platform !== 'win32',
-            });
-            child.stdin.end();
-        }
-        catch (cause) {
-            reject(new Error('Astrale CLI is unavailable.', { cause }));
-            return;
-        }
-        let stdout = '';
-        let stderr = '';
-        let stdoutBytes = 0;
-        let stderrBytes = 0;
-        let settled = false;
-        let termination;
-        let escalation;
-        const abort = () => terminate(input.signal.reason instanceof Error
-            ? input.signal.reason
-            : new Error('Project operation interrupted.'));
-        input.signal.addEventListener('abort', abort, { once: true });
-        const cleanup = () => {
-            clearTimeout(timeout);
-            if (escalation !== undefined)
-                clearTimeout(escalation);
-            input.signal.removeEventListener('abort', abort);
-        };
-        const terminate = (cause) => {
-            if (settled || termination !== undefined)
-                return;
-            termination = cause;
-            child.stdin.destroy();
-            child.kill('SIGTERM');
-            escalation = setTimeout(() => {
-                if (child.exitCode === null && child.signalCode === null)
-                    child.kill('SIGKILL');
-            }, TERMINATION_GRACE_MS);
-        };
-        const timeout = setTimeout(() => terminate(new Error('Astrale CLI command timed out.')), input.timeoutMs);
-        child.stdout.on('data', (chunk) => {
-            stdoutBytes += chunk.byteLength;
-            if (stdoutBytes > OUTPUT_LIMIT) {
-                terminate(new Error('Astrale CLI stdout exceeded the supported limit.'));
-            }
-            else
-                stdout += chunk.toString('utf8');
-        });
-        child.stderr.on('data', (chunk) => {
-            stderrBytes += chunk.byteLength;
-            if (stderrBytes > OUTPUT_LIMIT) {
-                terminate(new Error('Astrale CLI stderr exceeded the supported limit.'));
-            }
-            else
-                stderr += chunk.toString('utf8');
-        });
-        child.once('error', (cause) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            reject(new Error('Astrale CLI could not be started.', { cause }));
-        });
-        child.once('close', (code) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            if (termination !== undefined) {
-                reject(termination);
-                return;
-            }
-            resolve(Object.freeze({ code: code ?? 1, stdout, stderr }));
-        });
-    });
-}
-function abortError(signal) {
-    return signal.reason instanceof Error
-        ? signal.reason
-        : new Error('Project operation interrupted.');
-}

package/dist/tooling/cli/astrale/version.d.ts

@@ -1,18 +0,0 @@
-import type { AstraleProcessResult } from './process.js';
-import { resolveAstraleExecutable } from './executable.js';
-export declare const MINIMUM_KERNEL_CLI_VERSION = "1.0.0-beta.48";
-export interface CompatibleAstraleDependencies {
-    readonly resolveExecutable: typeof resolveAstraleExecutable;
-    readonly run: (input: {
-        readonly executable: string;
-        readonly args: readonly string[];
-        readonly projectDir: string;
-        readonly signal: AbortSignal;
-        readonly timeoutMs: number;
-    }) => Promise<AstraleProcessResult>;
-}
-/** Pin and admit one compatible CLI before any configured Kernel installation effect. */
-export declare function resolveCompatibleAstrale(input: {
-    readonly projectDir: string;
-    readonly signal: AbortSignal;
-}, dependencies?: CompatibleAstraleDependencies): Promise<string>;

package/dist/tooling/cli/astrale/version.js

@@ -1,55 +0,0 @@
-import { resolveAstraleExecutable } from './executable.js';
-import { astraleFailure } from './failure.js';
-import { runAstrale } from './process.js';
-export const MINIMUM_KERNEL_CLI_VERSION = '1.0.0-beta.48';
-/** Pin and admit one compatible CLI before any configured Kernel installation effect. */
-export async function resolveCompatibleAstrale(input, dependencies = {
-    resolveExecutable: resolveAstraleExecutable,
-    run: runAstrale,
-}) {
-    const executable = await dependencies.resolveExecutable();
-    const result = await dependencies.run({
-        executable,
-        projectDir: input.projectDir,
-        args: ['--version'],
-        signal: input.signal,
-        timeoutMs: 10_000,
-    });
-    if (result.code !== 0)
-        throw astraleFailure('version', result);
-    const version = result.stdout.trim().replace(/^v/u, '');
-    if (!isCompatible(version)) {
-        const diagnostic = semver(version) === undefined ? '<invalid>' : version;
-        throw new TypeError(`Astrale CLI ${diagnostic} is incompatible; ${MINIMUM_KERNEL_CLI_VERSION} or newer is required.`);
-    }
-    return executable;
-}
-function isCompatible(input) {
-    const value = semver(input);
-    const minimum = semver(MINIMUM_KERNEL_CLI_VERSION);
-    if (value === undefined)
-        return false;
-    for (let index = 0; index < 3; index += 1) {
-        if (value.core[index] > minimum.core[index])
-            return true;
-        if (value.core[index] < minimum.core[index])
-            return false;
-    }
-    if (value.prerelease === undefined)
-        return true;
-    if (minimum.prerelease === undefined)
-        return false;
-    if (value.prerelease.name !== minimum.prerelease.name) {
-        return value.prerelease.name.localeCompare(minimum.prerelease.name) > 0;
-    }
-    return value.prerelease.number >= minimum.prerelease.number;
-}
-function semver(input) {
-    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([a-z]+)\.(\d+))?$/u.exec(input);
-    if (match === null)
-        return undefined;
-    return {
-        core: [Number(match[1]), Number(match[2]), Number(match[3])],
-        ...(match[4] === undefined ? {} : { prerelease: { name: match[4], number: Number(match[5]) } }),
-    };
-}

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

@@ -1,16 +0,0 @@
-import type { ReadyDeployResult } from '../../../deployment/adapter/index.js';
-import type { InstallationEvidence } from '../installation/index.js';
-import type { DevelopmentCandidate } from './candidate.js';
-export interface DevelopmentDeploymentInput {
-    readonly projectDir: string;
-    readonly environment: string;
-    readonly deployOnly: boolean;
-    readonly identity?: string;
-    readonly credential?: string;
-    readonly installationExecutable?: string;
-}
-/** Commit and verify one complete remote candidate, then reconcile its optional installation. */
-export declare function deployDevelopmentCandidate(candidate: DevelopmentCandidate, input: DevelopmentDeploymentInput, signal: AbortSignal): Promise<{
-    readonly deployment: ReadyDeployResult;
-    readonly installation?: InstallationEvidence;
-}>;

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

@@ -1,39 +0,0 @@
-import { verifyDeployment } from '../../../deployment/index.js';
-import { reconcileEnvironmentRelease } from '../environment-release.js';
-/** Commit and verify one complete remote candidate, then reconcile its optional installation. */
-export async function deployDevelopmentCandidate(candidate, input, signal) {
-    const deployed = await candidate.adapter.deploy(candidate.parameters, {
-        projectDir: input.projectDir,
-        environment: input.environment,
-        ...(candidate.installation === undefined ? {} : { installation: candidate.installation }),
-        ...(input.identity === undefined ? {} : { identity: input.identity }),
-        ...(input.credential === undefined ? {} : { credential: input.credential }),
-        secrets: candidate.secrets,
-        artifact: candidate.artifact,
-        signal,
-    });
-    const verified = verifyDeployment(candidate.artifact, deployed);
-    if (verified.status === 'failed') {
-        throw new Error(`Deployment failed during ${verified.phase}: ${verified.error.message}`, {
-            cause: verified.error,
-        });
-    }
-    const installation = await reconcileEnvironmentRelease({
-        projectDir: input.projectDir,
-        environment: input.environment,
-        adapter: candidate.adapter,
-        deployment: verified,
-        ...(candidate.installation === undefined ? {} : { installation: candidate.installation }),
-        deployOnly: input.deployOnly,
-        ...(input.installationExecutable === undefined
-            ? {}
-            : { installationExecutable: input.installationExecutable }),
-        ...(input.identity === undefined ? {} : { identity: input.identity }),
-        ...(input.credential === undefined ? {} : { credential: input.credential }),
-        signal,
-    });
-    return Object.freeze({
-        deployment: verified,
-        ...(installation === undefined ? {} : { installation }),
-    });
-}

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

@@ -1,11 +0,0 @@
-/** Watch one Project Environment and serialize complete remote deployment generations. */
-export declare function develop(input: {
-    readonly configPath: string;
-    readonly projectDir: string;
-    readonly environment: string;
-    readonly deployOnly: boolean;
-    readonly identity?: string;
-    readonly credentialFile?: string;
-    readonly sessionFile?: string;
-    readonly secretsFile?: string;
-}): Promise<number>;