@astrale-os/adapter-astrale 0.5.0-beta.21 → 0.5.0-beta.23

package/dist/adapter.d.ts

@@ -1,17 +1,9 @@
 import type { ArtifactSource, PrepareContext, WatchContext, WatchHandle } from '@astrale-os/sdk/deployment/adapter';
-import { signingIdentity } from '@astrale-os/adapter-cloudflare/build';
+import type { AstraleDeployDependencies } from './deploy/deploy.js';
 import type { AstraleParams } from './params.js';
-import { callAstrale, runAstrale } from './cli.js';
-import { ensureServices } from './prerequisite.js';
-import { waitForReadiness } from './service/readiness.js';
-export interface AstraleDependencies {
+export interface AstraleDependencies extends AstraleDeployDependencies {
     prepare(parameters: AstraleParams, context: PrepareContext): Promise<ArtifactSource>;
     watch(parameters: AstraleParams, context: WatchContext): Promise<WatchHandle>;
-    ensureServices: typeof ensureServices;
-    callAstrale: typeof callAstrale;
-    runAstrale: typeof runAstrale;
-    waitForReadiness: typeof waitForReadiness;
-    signingIdentity: typeof signingIdentity;
 }
 export declare function astrale(environments: Readonly<Record<string, AstraleParams>>): import("@astrale-os/sdk/deployment/adapter").Adapter<AstraleParams>;
 export declare function astraleWithDependencies(environments: Readonly<Record<string, AstraleParams>>, dependencies: AstraleDependencies): import("@astrale-os/sdk/deployment/adapter").Adapter<AstraleParams>;

package/dist/adapter.js

@@ -1,25 +1,26 @@
-import { cloudflare } from '@astrale-os/adapter-cloudflare';
-import { signingIdentity, signingIdentitySecrets } from '@astrale-os/adapter-cloudflare/build';
+import { signingIdentity } from '@astrale-os/adapter-cloudflare/build';
 import { defineAdapter } from '@astrale-os/sdk/deployment/adapter';
-import { addressing, assemble } from '@astrale-os/sdk/deployment/release';
 import { createRequire } from 'node:module';
-import { callAstrale, identityArguments, runAstrale } from './cli.js';
-import { ensureServices, ServicesPrerequisiteError } from './prerequisite.js';
-import { serviceName, servicePath, servicesDeployMethod } from './service/addressing.js';
-import { deploymentPayload } from './service/artifact.js';
-import { waitForReadiness } from './service/readiness.js';
-const SERVICES_ORIGIN = 'services.astrale.ai';
-const NONE = Object.freeze({ kind: 'none' });
+import { callAstrale } from './cli/commands/call.js';
+import { installDomain } from './cli/commands/install-domain.js';
+import { introspectDomain } from './cli/commands/introspect.js';
+import { requireCliVersion } from './cli/commands/version.js';
+import { deployAstrale } from './deploy/deploy.js';
+import { ensureServices } from './deploy/ensure-services.js';
+import { waitForReadiness } from './deploy/readiness.js';
+import { prepareAstrale } from './prepare/prepare.js';
+import { watchAstrale } from './prepare/watch.js';
 const packageVersion = createRequire(import.meta.url)('../package.json')
     .version;
-const local = cloudflare({ internal: {} });
 export function astrale(environments) {
     return astraleWithDependencies(environments, {
-        prepare: (parameters, context) => local.prepare(cloudflareParameters(parameters, false), context),
-        watch: (parameters, context) => local.watch(cloudflareParameters(parameters, true), context),
+        prepare: prepareAstrale,
+        watch: watchAstrale,
         ensureServices,
         callAstrale,
-        runAstrale,
+        introspectDomain,
+        installDomain,
+        requireCliVersion,
         waitForReadiness,
         signingIdentity,
     });
@@ -31,246 +32,7 @@ export function astraleWithDependencies(environments, dependencies) {
         environments,
         prepare: dependencies.prepare,
         watch: dependencies.watch,
-        async deploy(parameters, context) {
-            if (parameters.instance === undefined) {
-                return failed('prerequisite', progress(), new TypeError('Astrale deployment requires an instance.'));
-            }
-            let secrets;
-            let signing;
-            try {
-                signing = await dependencies.signingIdentity({
-                    projectDir: context.projectDir,
-                    source: parameters.signingIdentity,
-                    origin: context.artifact.build.schema.compiled.root.origin,
-                    mode: 'deploy',
-                });
-                secrets = signingIdentitySecrets(context.secrets, signing);
-            }
-            catch (cause) {
-                return failed('prerequisite', progress(), cause);
-            }
-            const instance = parameters.instance;
-            const servicesOrigin = parameters.servicesOrigin ?? SERVICES_ORIGIN;
-            const identity = identityArguments(parameters.identity);
-            let prerequisite;
-            try {
-                const evidence = await dependencies.ensureServices({
-                    projectDir: context.projectDir,
-                    instance,
-                    servicesOrigin,
-                    identity,
-                    run: dependencies.runAstrale,
-                });
-                prerequisite =
-                    evidence.state === 'installed'
-                        ? Object.freeze({ kind: 'applied', evidence })
-                        : NONE;
-            }
-            catch (cause) {
-                const prerequisite = cause instanceof ServicesPrerequisiteError && cause.mutation === 'installed'
-                    ? Object.freeze({
-                        kind: 'applied',
-                        evidence: Object.freeze({ origin: servicesOrigin, state: 'installed' }),
-                    })
-                    : cause instanceof ServicesPrerequisiteError && cause.mutation === 'unknown'
-                        ? Object.freeze({ kind: 'unknown' })
-                        : NONE;
-                return failed('prerequisite', progress({ prerequisite }), cause);
-            }
-            const origin = context.artifact.build.schema.compiled.root.origin;
-            const name = parameters.name ?? serviceName(origin);
-            let payload;
-            try {
-                payload = deploymentPayload(context.artifact, { origin, name, vars: parameters.vars });
-            }
-            catch (cause) {
-                return failed('provider', progress({ prerequisite }), cause);
-            }
-            let deployed;
-            try {
-                deployed = await dependencies.callAstrale({
-                    projectDir: context.projectDir,
-                    instance,
-                    path: servicesDeployMethod(servicesOrigin),
-                    identity,
-                    data: payload,
-                });
-            }
-            catch (cause) {
-                return failed('provider', progress({ prerequisite, provider: { kind: 'unknown' } }), cause);
-            }
-            const expectedPath = servicePath(origin);
-            let observation;
-            try {
-                observation = deployedService(deployed, expectedPath);
-            }
-            catch (cause) {
-                return failed('provider', progress({
-                    prerequisite,
-                    provider: { kind: 'partial' },
-                }), cause);
-            }
-            const url = observation.url;
-            const applied = Object.freeze({
-                kind: 'applied',
-                evidence: Object.freeze({
-                    provider: 'astrale',
-                    deployment: observation.digest,
-                    artifact: context.artifact.digest,
-                }),
-            });
-            if (url === undefined) {
-                return failed('addressing', progress({ prerequisite, provider: applied }), new Error('Astrale Services deployment returned no URL.'));
-            }
-            let selected;
-            try {
-                selected = addressing(url);
-            }
-            catch (cause) {
-                return failed('addressing', progress({ prerequisite, provider: applied }), cause);
-            }
-            const provider = Object.freeze({
-                kind: 'applied',
-                evidence: Object.freeze({ ...applied.evidence, issuer: selected.issuer }),
-            });
-            let configuration = NONE;
-            const secretNames = [signing.binding, ...Object.keys(context.secrets).sort()];
-            const configured = [];
-            if (secretNames.length > 0) {
-                try {
-                    for (const secret of secretNames) {
-                        await dependencies.callAstrale({
-                            projectDir: context.projectDir,
-                            instance,
-                            path: `${servicePath(origin)}::setSecret`,
-                            identity,
-                            data: { name: secret, value: secrets[secret] },
-                        });
-                        configured.push(secret);
-                    }
-                    configuration = Object.freeze({
-                        kind: 'applied',
-                        evidence: Object.freeze({ names: secretNames }),
-                    });
-                }
-                catch (cause) {
-                    const configuration = configured.length === 0
-                        ? { kind: 'unknown' }
-                        : {
-                            kind: 'partial',
-                            evidence: Object.freeze({ names: Object.freeze([...configured]) }),
-                        };
-                    return failed('configuration', progress({ prerequisite, provider, configuration }), cause);
-                }
-            }
-            let release;
-            try {
-                release = assemble(context.artifact.build, selected);
-            }
-            catch (cause) {
-                return failed('release', progress({ prerequisite, provider, configuration }), cause);
-            }
-            try {
-                await dependencies.waitForReadiness(release);
-            }
-            catch (cause) {
-                return failed('readiness', progress({ prerequisite, provider, configuration }), cause, release);
-            }
-            let installation;
-            try {
-                await dependencies.runAstrale({
-                    projectDir: context.projectDir,
-                    input: [
-                        'domain',
-                        'install',
-                        url,
-                        '--direct',
-                        '-i',
-                        instance,
-                        '--allow-identity-override',
-                        '--json',
-                        '--timeout',
-                        '240000',
-                        ...identity,
-                    ],
-                });
-                installation = Object.freeze({
-                    kind: 'applied',
-                    evidence: Object.freeze({ instance, origin }),
-                });
-            }
-            catch (cause) {
-                return failed('installation', progress({ prerequisite, provider, configuration, installation: { kind: 'unknown' } }), cause, release);
-            }
-            return Object.freeze({
-                status: 'ready',
-                phase: 'complete',
-                progress: Object.freeze({
-                    ...progress({ prerequisite, configuration, installation }),
-                    provider,
-                }),
-                release,
-            });
-        },
+        deploy: (parameters, context) => deployAstrale(parameters, context, dependencies),
         secretsFile: (parameters) => parameters.secrets,
     });
 }
-function cloudflareParameters(parameters, watch) {
-    return Object.freeze({
-        ...(parameters.port === undefined ? {} : { port: parameters.port }),
-        ...(watch && parameters.host !== undefined ? { host: parameters.host } : {}),
-        ...(parameters.vars === undefined ? {} : { vars: parameters.vars }),
-        ...(parameters.signingIdentity === undefined
-            ? {}
-            : { signingIdentity: parameters.signingIdentity }),
-    });
-}
-function deployedService(input, expectedPath) {
-    if (input === null || typeof input !== 'object' || Array.isArray(input))
-        invalidDeployment();
-    const value = input;
-    if (value.error !== undefined && value.error !== null)
-        invalidDeployment();
-    if (value.state !== 'ready') {
-        throw new TypeError('Astrale Services deployment did not report ready provider state.');
-    }
-    if (value.path !== expectedPath) {
-        throw new TypeError('Astrale Services deployment returned a different Service path.');
-    }
-    if (typeof value.digest !== 'string' || value.digest.length === 0) {
-        throw new TypeError('Astrale Services deployment returned an invalid provider digest.');
-    }
-    let url;
-    if (typeof value.url === 'string') {
-        try {
-            url = new URL(value.url).href.replace(/\/$/u, '');
-        }
-        catch {
-            // Addressing admission below retains the successful provider effect.
-        }
-    }
-    return Object.freeze({
-        ...(url === undefined ? {} : { url }),
-        digest: value.digest,
-    });
-}
-function invalidDeployment() {
-    throw new TypeError('Astrale Services deployment returned invalid provider evidence.');
-}
-function progress(input = {}) {
-    return Object.freeze({
-        prerequisite: input.prerequisite ?? NONE,
-        provider: input.provider ?? NONE,
-        configuration: input.configuration ?? NONE,
-        installation: input.installation ?? NONE,
-    });
-}
-function failed(phase, deploymentProgress, cause, release) {
-    return Object.freeze({
-        status: 'failed',
-        phase,
-        progress: deploymentProgress,
-        error: cause instanceof Error ? cause : new Error(String(cause)),
-        ...(release === undefined ? {} : { release }),
-    });
-}

package/dist/cli/commands/call.d.ts

@@ -0,0 +1,8 @@
+export declare function callAstrale(input: {
+    readonly projectDir: string;
+    readonly instance: string;
+    readonly path: string;
+    readonly identity: readonly string[];
+    readonly data: unknown;
+    readonly signal: AbortSignal;
+}): Promise<unknown>;

package/dist/cli/commands/call.js

@@ -0,0 +1,26 @@
+import { CliProcessError } from '../error.js';
+import { decodeJson } from '../json.js';
+import { runCliProcess } from '../process.js';
+export async function callAstrale(input) {
+    const result = await runCliProcess({
+        projectDir: input.projectDir,
+        args: [
+            '--ci',
+            '--no-prompt',
+            'call',
+            input.path,
+            '-i',
+            input.instance,
+            '--json',
+            '--timeout',
+            '240000',
+            ...input.identity,
+        ],
+        stdin: JSON.stringify(input.data),
+        signal: input.signal,
+        timeoutMs: 250_000,
+    });
+    if (!result.ok)
+        throw new CliProcessError('command', `call ${input.path}`, result.failure);
+    return decodeJson(result.stdout, `astrale call ${input.path} success`);
+}

package/dist/cli/commands/install-domain.d.ts

@@ -0,0 +1,9 @@
+export declare function installDomain(input: {
+    readonly projectDir: string;
+    readonly instance: string;
+    readonly target: string;
+    readonly direct: boolean;
+    readonly allowIdentityOverride?: boolean;
+    readonly identity: readonly string[];
+    readonly signal: AbortSignal;
+}): Promise<unknown>;

package/dist/cli/commands/install-domain.js

@@ -0,0 +1,28 @@
+import { CliProcessError } from '../error.js';
+import { decodeJson } from '../json.js';
+import { runCliProcess } from '../process.js';
+export async function installDomain(input) {
+    const result = await runCliProcess({
+        projectDir: input.projectDir,
+        args: [
+            '--ci',
+            '--no-prompt',
+            'domain',
+            'install',
+            input.target,
+            ...(input.direct ? ['--direct'] : []),
+            '-i',
+            input.instance,
+            ...(input.allowIdentityOverride ? ['--allow-identity-override'] : []),
+            '--json',
+            '--timeout',
+            '240000',
+            ...input.identity,
+        ],
+        signal: input.signal,
+        timeoutMs: 250_000,
+    });
+    if (!result.ok)
+        throw new CliProcessError('command', 'domain install', result.failure);
+    return decodeJson(result.stdout, 'astrale domain install success');
+}

package/dist/cli/commands/introspect.d.ts

@@ -0,0 +1,7 @@
+export declare function introspectDomain(input: {
+    readonly projectDir: string;
+    readonly instance: string;
+    readonly origin: string;
+    readonly identity: readonly string[];
+    readonly signal: AbortSignal;
+}): Promise<unknown>;

package/dist/cli/commands/introspect.js

@@ -0,0 +1,26 @@
+import { CliProcessError } from '../error.js';
+import { decodeJson } from '../json.js';
+import { runCliProcess } from '../process.js';
+export async function introspectDomain(input) {
+    const result = await runCliProcess({
+        projectDir: input.projectDir,
+        args: [
+            '--ci',
+            '--no-prompt',
+            'introspect',
+            input.origin,
+            '-i',
+            input.instance,
+            '--json',
+            '--timeout',
+            '60000',
+            ...input.identity,
+        ],
+        signal: input.signal,
+        timeoutMs: 70_000,
+    });
+    if (!result.ok) {
+        throw new CliProcessError('command', `introspect ${input.origin}`, result.failure);
+    }
+    return decodeJson(result.stdout, `astrale introspect ${input.origin} success`);
+}

package/dist/cli/commands/version.d.ts

@@ -0,0 +1,5 @@
+export declare const MINIMUM_ASTRALE_CLI_VERSION = "1.0.0-beta.8";
+export declare function requireCliVersion(input: {
+    readonly projectDir: string;
+    readonly signal: AbortSignal;
+}): Promise<string>;

package/dist/cli/commands/version.js

@@ -0,0 +1,49 @@
+import { CliProcessError } from '../error.js';
+import { runCliProcess } from '../process.js';
+export const MINIMUM_ASTRALE_CLI_VERSION = '1.0.0-beta.8';
+export async function requireCliVersion(input) {
+    const result = await runCliProcess({
+        projectDir: input.projectDir,
+        args: ['--version'],
+        signal: input.signal,
+        timeoutMs: 10_000,
+        stdoutLimit: 256,
+        stderrLimit: 4_096,
+    });
+    if (!result.ok)
+        throw new CliProcessError('command', 'version', result.failure);
+    const version = result.stdout.trim().replace(/^v/u, '');
+    if (!isCompatible(version)) {
+        throw new TypeError(`Astrale CLI ${version || '<invalid>'} is incompatible; ${MINIMUM_ASTRALE_CLI_VERSION} or newer is required.`);
+    }
+    return version;
+}
+function isCompatible(input) {
+    const value = semver(input);
+    const minimum = semver(MINIMUM_ASTRALE_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/cli/error.d.ts

@@ -0,0 +1,7 @@
+export type CliProcessFailureKind = 'cancelled' | 'timeout' | 'output-limit' | 'spawn' | 'protocol' | 'command';
+export declare class CliProcessError extends Error {
+    readonly kind: CliProcessFailureKind;
+    readonly command: string;
+    readonly diagnostic?: Readonly<Record<string, unknown>> | undefined;
+    constructor(kind: CliProcessFailureKind, command: string, diagnostic?: Readonly<Record<string, unknown>> | undefined, options?: ErrorOptions);
+}

package/dist/cli/error.js

@@ -0,0 +1,13 @@
+export class CliProcessError extends Error {
+    kind;
+    command;
+    diagnostic;
+    constructor(kind, command, diagnostic, options) {
+        const code = typeof diagnostic?.error === 'string' ? ` (${diagnostic.error})` : '';
+        super(`Astrale CLI ${command} failed: ${kind}${code}.`, options);
+        this.kind = kind;
+        this.command = command;
+        this.diagnostic = diagnostic;
+        this.name = 'CliProcessError';
+    }
+}

package/dist/cli/identity.d.ts

@@ -0,0 +1 @@
+export declare function identityArguments(identity: string | undefined): readonly string[];

package/dist/cli/identity.js

@@ -0,0 +1,3 @@
+export function identityArguments(identity) {
+    return identity === undefined ? [] : ['--as', identity];
+}

package/dist/cli/json.d.ts

@@ -0,0 +1,3 @@
+export declare function decodeJson(input: string, label: string): unknown;
+export declare function decodeFailure(input: string): Readonly<Record<string, unknown>>;
+export declare function isDomainNotInstalledFailure(input: Readonly<Record<string, unknown>>): boolean;

package/dist/cli/json.js

@@ -0,0 +1,25 @@
+export function decodeJson(input, label) {
+    if (input.trim().length === 0)
+        throw new TypeError(`${label} is empty.`);
+    try {
+        return JSON.parse(input);
+    }
+    catch (cause) {
+        throw new TypeError(`${label} is not one complete JSON value.`, { cause });
+    }
+}
+export function decodeFailure(input) {
+    const value = decodeJson(input, 'Astrale CLI failure');
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        invalid();
+    const record = value;
+    if (typeof record.error !== 'string' || record.error.length === 0)
+        invalid();
+    return Object.freeze({ error: record.error });
+}
+export function isDomainNotInstalledFailure(input) {
+    return input.error === 'DOMAIN_NOT_INSTALLED';
+}
+function invalid() {
+    throw new TypeError('Astrale CLI failure envelope is invalid.');
+}

package/dist/cli/process.d.ts

@@ -0,0 +1,17 @@
+export interface CliProcessInput {
+    readonly projectDir: string;
+    readonly args: readonly string[];
+    readonly signal: AbortSignal;
+    readonly timeoutMs: number;
+    readonly stdin?: string;
+    readonly stdoutLimit?: number;
+    readonly stderrLimit?: number;
+}
+export type CliProcessResult = {
+    readonly ok: true;
+    readonly stdout: string;
+} | {
+    readonly ok: false;
+    readonly failure: Readonly<Record<string, unknown>>;
+};
+export declare function runCliProcess(input: CliProcessInput): Promise<CliProcessResult>;

package/dist/cli/process.js

@@ -0,0 +1,108 @@
+import { spawn } from 'node:child_process';
+import { CliProcessError } from './error.js';
+import { decodeFailure } from './json.js';
+const DEFAULT_LIMIT = 256 * 1024;
+const TERMINATION_GRACE_MS = 1_000;
+export function runCliProcess(input) {
+    const command = commandName(input.args);
+    if (input.signal.aborted) {
+        return Promise.reject(new CliProcessError('cancelled', command));
+    }
+    if (!Number.isSafeInteger(input.timeoutMs) || input.timeoutMs <= 0) {
+        return Promise.reject(new TypeError('Astrale CLI timeout must be a positive integer.'));
+    }
+    return new Promise((resolve, reject) => {
+        let child;
+        try {
+            child = spawn('astrale', [...input.args], {
+                cwd: input.projectDir,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                shell: false,
+            });
+        }
+        catch (cause) {
+            reject(new CliProcessError('spawn', command, undefined, { cause }));
+            return;
+        }
+        let stdout = '';
+        let stderr = '';
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
+        let settled = false;
+        let terminationKind;
+        let escalation;
+        const timeout = setTimeout(() => terminate('timeout'), input.timeoutMs);
+        const abort = () => terminate('cancelled');
+        input.signal.addEventListener('abort', abort, { once: true });
+        const finish = (handler) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            if (escalation !== undefined)
+                clearTimeout(escalation);
+            input.signal.removeEventListener('abort', abort);
+            handler();
+        };
+        const fail = (error) => finish(() => reject(error));
+        const terminate = (kind) => {
+            if (settled || terminationKind !== undefined)
+                return;
+            terminationKind = kind;
+            child.stdin.destroy();
+            child.kill('SIGTERM');
+            escalation = setTimeout(() => {
+                if (child.exitCode === null && child.signalCode === null)
+                    child.kill('SIGKILL');
+            }, TERMINATION_GRACE_MS);
+        };
+        child.stdout.on('data', (chunk) => {
+            stdoutBytes += chunk.byteLength;
+            if (stdoutBytes > (input.stdoutLimit ?? DEFAULT_LIMIT))
+                terminate('output-limit');
+            else
+                stdout += chunk.toString('utf8');
+        });
+        child.stderr.on('data', (chunk) => {
+            stderrBytes += chunk.byteLength;
+            if (stderrBytes > (input.stderrLimit ?? DEFAULT_LIMIT))
+                terminate('output-limit');
+            else
+                stderr += chunk.toString('utf8');
+        });
+        child.once('error', (cause) => fail(terminationKind === undefined
+            ? new CliProcessError('spawn', command, undefined, { cause })
+            : new CliProcessError(terminationKind, command, undefined, { cause })));
+        child.once('close', (code) => {
+            if (settled)
+                return;
+            if (terminationKind !== undefined) {
+                fail(new CliProcessError(terminationKind, command));
+                return;
+            }
+            const out = stdout;
+            const error = stderr;
+            if (code === 0) {
+                finish(() => resolve(Object.freeze({ ok: true, stdout: out })));
+                return;
+            }
+            let failure;
+            try {
+                failure = decodeFailure(error);
+            }
+            catch (cause) {
+                fail(new CliProcessError('protocol', command, undefined, { cause }));
+                return;
+            }
+            finish(() => resolve(Object.freeze({ ok: false, failure })));
+        });
+        if (input.stdin === undefined)
+            child.stdin.end();
+        else
+            child.stdin.end(input.stdin);
+    });
+}
+function commandName(args) {
+    const visible = args.filter((arg) => !arg.startsWith('-')).slice(0, 2);
+    return visible.join(' ') || 'version';
+}