@astrale-os/adapter-cloudflare 0.5.0-beta.13 → 0.5.0-beta.130

package/dist/build/worker/execution.prepare.js

@@ -0,0 +1,115 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+import { SIGNING_IDENTITY_BINDING } from '../../identity/binding.js';
+import { runWranglerBundle } from '../../wrangler/bundle.js';
+import { admitWorkerBundle } from '../bundle/admit.js';
+import { generateExecutionEntry, generateExecutionService } from '../codegen/execution.js';
+import { generateWranglerConfig } from '../codegen/wrangler.js';
+import { workerInvocationTimeout, workerRequestLimit } from '../configuration.js';
+import { qualifyWorkerBundle } from '../qualification.js';
+import { workerModuleSpecifier } from './specifier.js';
+export const RELEASE_ENTRY = 'bundle/index.mjs';
+export const RELEASE_SERVICE = 'bundle/service.mjs';
+export async function prepareExecution(input) {
+    const runtimePath = resolve(input.context.projectDir, input.context.runtime.reference.path);
+    const runtimeSpecifier = moduleSpecifier(relative(input.directory, runtimePath));
+    const workerSpecifier = workerModuleSpecifier();
+    const maximumRequestBytes = workerRequestLimit(input.params.maximumRequestBytes);
+    const invocationTimeoutMs = workerInvocationTimeout(input.params.invocationTimeoutMs);
+    const serviceSource = generateExecutionService({
+        origin: input.context.build.schema.compiled.root.origin,
+        runtimeSpecifier,
+        workerSpecifier,
+        build: input.context.build,
+        ...(input.frontendRevision === undefined ? {} : { frontendRevision: input.frontendRevision }),
+        ...(maximumRequestBytes === undefined ? {} : { maximumRequestBytes }),
+        ...(invocationTimeoutMs === undefined ? {} : { invocationTimeoutMs }),
+        ...(input.params.tokenExchange === undefined
+            ? {}
+            : { tokenExchange: input.params.tokenExchange }),
+        ...(input.configuredIssuer === undefined && input.direct
+            ? { providerAssignedWorker: input.name }
+            : {}),
+        ...(input.router === undefined
+            ? {}
+            : {
+                router: {
+                    binding: input.router.binding,
+                    hostSuffix: input.router.hostSuffix,
+                    minLabels: input.router.minLabels,
+                },
+            }),
+    });
+    const serviceSourcePath = join(input.directory, 'service.gen.ts');
+    await writeFile(serviceSourcePath, serviceSource);
+    const serviceConfigPath = join(input.directory, 'wrangler.service.prepare.jsonc');
+    await writeFile(serviceConfigPath, generateWranglerConfig({
+        workerName: input.name,
+        main: './service.gen.ts',
+        vars: runtimeVars(input.params, input.configuredIssuer),
+        secretBindings: [SIGNING_IDENTITY_BINDING],
+        ...(input.router === undefined
+            ? {}
+            : { router: { binding: input.router.binding, service: input.router.service } }),
+        ...(input.params.wrangler === undefined ? {} : { wrangler: input.params.wrangler }),
+        selfBinding: false,
+    }));
+    const serviceOutput = join(input.directory, 'dist-service');
+    await rm(serviceOutput, { recursive: true, force: true });
+    const emittedService = await runWranglerBundle({
+        projectDir: input.context.projectDir,
+        configPath: serviceConfigPath,
+        outDir: serviceOutput,
+        signal: input.context.signal,
+    });
+    await qualifyWorkerBundle({
+        metafilePath: emittedService.metafilePath,
+        inputRoot: dirname(serviceConfigPath),
+    });
+    await admitWorkerBundle(emittedService.bundlePath);
+    const service = new Uint8Array(await readFile(emittedService.bundlePath));
+    await mkdir(dirname(join(input.directory, RELEASE_SERVICE)), { recursive: true });
+    await writeFile(join(input.directory, RELEASE_SERVICE), service);
+    const sourcePath = join(input.directory, 'worker.gen.ts');
+    await writeFile(sourcePath, generateExecutionEntry('./service.mjs', workerSpecifier));
+    const configPath = join(input.directory, 'wrangler.prepare.jsonc');
+    await writeFile(configPath, generateWranglerConfig({
+        workerName: input.name,
+        ...(input.params.route === undefined ? {} : { route: input.params.route }),
+        vars: runtimeVars(input.params, input.configuredIssuer),
+        secretBindings: [SIGNING_IDENTITY_BINDING],
+        modules: { baseDir: '.', rules: [{ type: 'ESModule', globs: [RELEASE_SERVICE] }] },
+        ...(input.router === undefined
+            ? {}
+            : { router: { binding: input.router.binding, service: input.router.service } }),
+        ...(input.params.wrangler === undefined ? {} : { wrangler: input.params.wrangler }),
+        selfBinding: false,
+    }));
+    const output = join(input.directory, 'dist-prepare');
+    await rm(output, { recursive: true, force: true });
+    const emitted = await runWranglerBundle({
+        projectDir: input.context.projectDir,
+        configPath,
+        outDir: output,
+        signal: input.context.signal,
+    });
+    await qualifyWorkerBundle({
+        metafilePath: emitted.metafilePath,
+        inputRoot: dirname(configPath),
+    });
+    await admitWorkerBundle(emitted.bundlePath);
+    return Object.freeze({
+        entry: new Uint8Array(await readFile(emitted.bundlePath)),
+        service,
+    });
+}
+export function runtimeVars(params, configuredIssuer) {
+    return {
+        ...params.vars,
+        ...(configuredIssuer === undefined ? {} : { WORKER_URL: configuredIssuer }),
+    };
+}
+function moduleSpecifier(input) {
+    const normalized = input.split('\\').join('/');
+    return normalized.startsWith('.') ? normalized : `./${normalized}`;
+}

package/dist/build/worker/index.d.ts

@@ -0,0 +1,2 @@
+export { loadWorkerArtifact } from './artifact.load.js';
+export type { WorkerArtifact } from './artifact.js';

package/dist/build/worker/index.js

@@ -0,0 +1 @@
+export { loadWorkerArtifact } from './artifact.load.js';

package/dist/build/worker/modules.d.ts

@@ -0,0 +1,11 @@
+import type { WorkerArtifact } from './artifact.js';
+type WranglerModuleType = 'ESModule' | 'CompiledWasm' | 'Text' | 'Data';
+/** Project one admitted Worker module inventory into Wrangler's relative module discovery. */
+export declare function workerModules(worker: WorkerArtifact['release']): {
+    readonly baseDir: string;
+    readonly rules: readonly {
+        readonly type: WranglerModuleType;
+        readonly globs: readonly string[];
+    }[];
+};
+export {};

package/dist/build/worker/modules.js

@@ -0,0 +1,26 @@
+import { posix } from 'node:path';
+const TYPES = Object.freeze({
+    esm: 'ESModule',
+    wasm: 'CompiledWasm',
+    text: 'Text',
+    data: 'Data',
+});
+/** Project one admitted Worker module inventory into Wrangler's relative module discovery. */
+export function workerModules(worker) {
+    const directory = posix.dirname(worker.entrypoint);
+    const groups = new Map();
+    for (const module of worker.modules) {
+        if (module.path === worker.entrypoint)
+            continue;
+        const relative = posix.relative(directory, module.path);
+        if (relative === '' || relative === '..' || relative.startsWith('../')) {
+            throw new TypeError('Cloudflare Worker module escapes its entrypoint directory.');
+        }
+        const type = TYPES[module.kind];
+        const globs = groups.get(type) ?? [];
+        globs.push(relative);
+        groups.set(type, globs);
+    }
+    const rules = [...groups].map(([type, globs]) => Object.freeze({ type, globs: Object.freeze(globs) }));
+    return Object.freeze({ baseDir: `./${directory}`, rules: Object.freeze(rules) });
+}

package/dist/build/worker/runtime.d.ts

@@ -0,0 +1,10 @@
+export interface WorkerRuntimeConfiguration {
+    readonly compatibilityDate: string;
+    readonly compatibilityFlags: readonly string[];
+    readonly vars: Readonly<Record<string, string>>;
+    readonly services: readonly {
+        readonly name: string;
+        readonly service: string;
+    }[];
+}
+export declare function admitWorkerRuntimeConfiguration(input: string): WorkerRuntimeConfiguration;

package/dist/build/worker/runtime.js

@@ -0,0 +1,35 @@
+export function admitWorkerRuntimeConfiguration(input) {
+    const value = JSON.parse(input);
+    const compatibilityDate = value.compatibility_date;
+    const compatibilityFlags = value.compatibility_flags;
+    const vars = value.vars ?? {};
+    const services = value.services ?? [];
+    if (typeof compatibilityDate !== 'string' ||
+        !Array.isArray(compatibilityFlags) ||
+        compatibilityFlags.some((flag) => typeof flag !== 'string') ||
+        vars === null ||
+        typeof vars !== 'object' ||
+        Array.isArray(vars) ||
+        Object.values(vars).some((item) => typeof item !== 'string') ||
+        !Array.isArray(services)) {
+        invalidRuntime();
+    }
+    const admittedServices = services.map((input) => {
+        if (input === null || typeof input !== 'object' || Array.isArray(input))
+            invalidRuntime();
+        const binding = Reflect.get(input, 'binding');
+        const service = Reflect.get(input, 'service');
+        if (typeof binding !== 'string' || typeof service !== 'string')
+            invalidRuntime();
+        return Object.freeze({ name: binding, service });
+    });
+    return Object.freeze({
+        compatibilityDate,
+        compatibilityFlags: Object.freeze([...compatibilityFlags]),
+        vars: Object.freeze({ ...vars }),
+        services: Object.freeze(admittedServices),
+    });
+}
+function invalidRuntime() {
+    throw new TypeError('Generated Cloudflare runtime configuration is invalid.');
+}

package/dist/build/worker/specifier.d.ts

@@ -0,0 +1 @@
+export declare function workerModuleSpecifier(): string;

package/dist/build/worker/specifier.js

@@ -0,0 +1,5 @@
+import { fileURLToPath } from 'node:url';
+const workerModule = import.meta.resolve('@astrale-os/adapter-cloudflare/worker');
+export function workerModuleSpecifier() {
+    return fileURLToPath(workerModule);
+}

package/dist/cloudflare.d.ts

@@ -1,45 +1 @@
-/**
- * `cloudflare(envs)` — the Cloudflare deployment adapter.
- *
- * Owns everything target-specific: it codegens the Worker entry + wrangler
- * config (the dev never sees a `wrangler.jsonc`), materializes the optional frontend
- * SPA, and shells out to `wrangler`. `watch` → `wrangler dev` (local URL);
- * `deploy` → `wrangler deploy` (workers.dev or a custom-domain URL); secrets →
- * `wrangler secret bulk`. Both `watch` and `deploy` return the URL the CLI
- * prints and `astrale domain install <url>` consumes.
- */
-import type { DomainAdapter } from '@astrale-os/sdk';
-import type { DeployFetch } from '@astrale-os/sdk/deployment';
-import { deployCheck } from '@astrale-os/sdk/deployment';
-import type { CloudflareParams } from './params.js';
-import { bulkPutSecrets, buildCloudflareWorker, buildFrontend, logTo, prepare, runWranglerDeploy, runWranglerDev, runWranglerTypes, startFrontendDev } from './build/index.js';
-export declare function cloudflare(envs: Record<string, CloudflareParams>): DomainAdapter<CloudflareParams>;
-interface CloudflareAdapterDependencies {
-    readonly bulkPutSecrets: typeof bulkPutSecrets;
-    readonly buildCloudflareWorker: typeof buildCloudflareWorker;
-    readonly buildFrontend: typeof buildFrontend;
-    readonly logTo: typeof logTo;
-    readonly prepare: typeof prepare;
-    readonly runWranglerDeploy: typeof runWranglerDeploy;
-    readonly runWranglerDev: typeof runWranglerDev;
-    readonly runWranglerTypes: typeof runWranglerTypes;
-    readonly startFrontendDev: typeof startFrontendDev;
-    readonly waitUntilLive: typeof waitUntilLive;
-}
-/** Exact orchestration seam used by adapter-level deployment qualification. */
-export declare function cloudflareWithDependencies(envs: Record<string, CloudflareParams>, dependencies: CloudflareAdapterDependencies): DomainAdapter<CloudflareParams>;
-/**
- * Poll until the deployed Worker exposes one complete canonical deployment chain.
- */
-export declare function waitUntilLive(url: string, onLog: (line: string) => void, expectations: {
-    readonly expectedOrigin: Parameters<typeof deployCheck>[0]['expectedOrigin'];
-    readonly expectedRevision: Parameters<typeof deployCheck>[0]['expectedRevision'];
-    readonly expectedDeploymentVersion?: string;
-    readonly fetch?: DeployFetch;
-    readonly timeoutMs?: number;
-    readonly fetchTimeoutMs?: number;
-    readonly retryMs?: number;
-    readonly sleep?: (ms: number) => Promise<void>;
-}): Promise<void>;
-export {};
-//# sourceMappingURL=cloudflare.d.ts.map
+export { cloudflare } from './adapter.js';

package/dist/cloudflare.js

@@ -1,202 +1 @@
-/**
- * `cloudflare(envs)` — the Cloudflare deployment adapter.
- *
- * Owns everything target-specific: it codegens the Worker entry + wrangler
- * config (the dev never sees a `wrangler.jsonc`), materializes the optional frontend
- * SPA, and shells out to `wrangler`. `watch` → `wrangler dev` (local URL);
- * `deploy` → `wrangler deploy` (workers.dev or a custom-domain URL); secrets →
- * `wrangler secret bulk`. Both `watch` and `deploy` return the URL the CLI
- * prints and `astrale domain install <url>` consumes.
- */
-import { defineAdapter } from '@astrale-os/sdk';
-import { deployCheck } from '@astrale-os/sdk/deployment';
-import { resolve } from 'node:path';
-import { bulkPutSecrets, buildCloudflareWorker, buildFrontend, logTo, prepare, runWranglerDeploy, runWranglerDev, runWranglerTypes, startFrontendDev, } from './build/index.js';
-export function cloudflare(envs) {
-    return cloudflareWithDependencies(envs, {
-        bulkPutSecrets,
-        buildCloudflareWorker,
-        buildFrontend,
-        logTo,
-        prepare,
-        runWranglerDeploy,
-        runWranglerDev,
-        runWranglerTypes,
-        startFrontendDev,
-        waitUntilLive,
-    });
-}
-/** Exact orchestration seam used by adapter-level deployment qualification. */
-export function cloudflareWithDependencies(envs, dependencies) {
-    const frontendDevUrls = new Map();
-    return defineAdapter({
-        name: 'cloudflare',
-        envs,
-        async build(params, ctx) {
-            await dependencies.buildCloudflareWorker({
-                params,
-                context: ctx,
-                onLog: dependencies.logTo(),
-            });
-        },
-        async watch(params, ctx) {
-            const onLog = dependencies.logTo();
-            const projectKey = resolve(ctx.projectDir);
-            let frontendDev;
-            let handle;
-            try {
-                frontendDev = await dependencies.startFrontendDev({
-                    definition: ctx.definition,
-                    projectDir: ctx.projectDir,
-                    onLog,
-                });
-                if (frontendDev !== undefined)
-                    frontendDevUrls.set(projectKey, frontendDev.url);
-                const { configPath, port } = await dependencies.prepare(params, ctx, 'dev', undefined, frontendDev?.url);
-                handle = await dependencies.runWranglerDev({
-                    projectDir: ctx.projectDir,
-                    configPath,
-                    port,
-                    remote: Boolean(params.remote),
-                    autoPickPort: params.port === undefined,
-                    ...(params.host ? { ip: '0.0.0.0' } : {}),
-                    onReload: ctx.onReload,
-                    onLog,
-                });
-            }
-            catch (error) {
-                frontendDevUrls.delete(projectKey);
-                try {
-                    await frontendDev?.stop();
-                }
-                catch (cleanupError) {
-                    throw new AggregateError([error, cleanupError], 'cloudflare development startup failed and Vite cleanup also failed');
-                }
-                throw error;
-            }
-            if (handle === undefined)
-                throw new Error('cloudflare local Worker failed to start');
-            // With --host the actionable URL is the PUBLIC one (the tunnel/proxy
-            // front), not the local bind — print and spec-stamp that.
-            return {
-                url: params.host ?? handle.url,
-                localUrl: handle.url,
-                async stop() {
-                    const errors = [];
-                    frontendDevUrls.delete(projectKey);
-                    try {
-                        await frontendDev?.stop();
-                    }
-                    catch (error) {
-                        errors.push(error);
-                    }
-                    try {
-                        await handle.stop();
-                    }
-                    catch (error) {
-                        errors.push(error);
-                    }
-                    if (errors.length === 1)
-                        throw errors[0];
-                    if (errors.length > 1) {
-                        throw new AggregateError(errors, 'cloudflare development cleanup failed');
-                    }
-                },
-            };
-        },
-        // Config hot-regen rewrites generated files only. Wrangler reloads its config and entry;
-        // the author-owned Vite process keeps its own source/config watch lifecycle.
-        async regenerate(params, ctx) {
-            const { configPath } = await dependencies.prepare(params, ctx, 'dev', undefined, frontendDevUrls.get(resolve(ctx.projectDir)));
-            await dependencies.runWranglerTypes({
-                projectDir: ctx.projectDir,
-                configPath,
-                onLog: dependencies.logTo(),
-            });
-        },
-        async deploy(params, ctx) {
-            const frontend = await dependencies.buildFrontend({
-                definition: ctx.definition,
-                projectDir: ctx.projectDir,
-                onLog: dependencies.logTo(),
-            });
-            const { configPath, fallbackConfigPath, workerName: name, } = await dependencies.prepare(params, ctx, 'deploy', frontend);
-            const { url, deploymentVersion } = await dependencies.runWranglerDeploy({
-                projectDir: ctx.projectDir,
-                configPath,
-                workerName: name,
-                ...(fallbackConfigPath ? { fallbackConfigPath } : {}),
-                ...(params.route ? { route: params.route } : {}),
-                onLog: dependencies.logTo(),
-            });
-            if (Object.keys(ctx.secrets).length > 0) {
-                await dependencies.bulkPutSecrets({
-                    projectDir: ctx.projectDir,
-                    configPath,
-                    secrets: ctx.secrets,
-                    onLog: dependencies.logTo(),
-                });
-            }
-            // A first deploy on a fresh `*.workers.dev` host can take ~30-60s to
-            // propagate; an `astrale domain install <url>` issued right away would
-            // 404 (Cloudflare 1042). Block until the URL actually serves so the
-            // install line we print is immediately actionable.
-            await dependencies.waitUntilLive(url, dependencies.logTo(), {
-                expectedOrigin: ctx.definition.schema.origin,
-                expectedRevision: ctx.definition.domain.$.revision,
-                ...(deploymentVersion === undefined
-                    ? {}
-                    : { expectedDeploymentVersion: deploymentVersion }),
-            });
-            return { url };
-        },
-        secretsFile(params) {
-            return params.secrets;
-        },
-    });
-}
-/**
- * Poll until the deployed Worker exposes one complete canonical deployment chain.
- */
-export async function waitUntilLive(url, onLog, expectations) {
-    const timeoutMs = expectations.timeoutMs ?? 90_000;
-    const fetchTimeoutMs = expectations.fetchTimeoutMs ?? 5_000;
-    const retryMs = expectations.retryMs ?? 3_000;
-    const sleep = expectations.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-    const deadline = Date.now() + timeoutMs;
-    let waited = false;
-    let lastReason = 'not checked';
-    for (;;) {
-        try {
-            const deployed = await deployCheck({
-                url,
-                expectedOrigin: expectations.expectedOrigin,
-                expectedRevision: expectations.expectedRevision,
-                signal: AbortSignal.timeout(fetchTimeoutMs),
-                ...(expectations.fetch === undefined ? {} : { fetch: expectations.fetch }),
-                log: () => undefined,
-            });
-            const actualDeploymentVersion = new URL(deployed.schema.bundle.href).searchParams.get('deployment');
-            if (expectations.expectedDeploymentVersion === undefined ||
-                actualDeploymentVersion === expectations.expectedDeploymentVersion) {
-                return;
-            }
-            lastReason =
-                `bundle deployment=${JSON.stringify(actualDeploymentVersion)} ` +
-                    `expected=${JSON.stringify(expectations.expectedDeploymentVersion)}`;
-        }
-        catch (error) {
-            lastReason = error instanceof Error ? error.message : String(error);
-        }
-        if (Date.now() >= deadline) {
-            throw new Error(`deployed Worker did not expose a valid Publication chain within ` +
-                `${Math.round(timeoutMs / 1000)}s; last check: ${lastReason}`);
-        }
-        if (!waited) {
-            waited = true;
-            onLog('waiting for the URL to go live (first deploys can take ~30-60s)…');
-        }
-        await sleep(Math.min(retryMs, Math.max(0, deadline - Date.now())));
-    }
-}
-//# sourceMappingURL=cloudflare.js.map
+export { cloudflare } from './adapter.js';

package/dist/deploy/deploy.d.ts

@@ -0,0 +1,17 @@
+import type { DeployContext, DeployResult } from '@astrale-os/sdk/deployment/adapter';
+import type { Release } from '@astrale-os/sdk/deployment/release';
+import type { materialize } from '../build/artifact.js';
+import type { WorkerArtifact } from '../build/worker/artifact.js';
+import type { signingIdentity } from '../identity/source.js';
+import type { CloudflareParams } from '../params.js';
+import type { runWranglerRollout } from '../wrangler/rollout.js';
+import type { runWranglerDeploymentStatus } from '../wrangler/status.js';
+export interface CloudflareDeployDependencies {
+    readonly materialize: typeof materialize;
+    readonly runWranglerRollout: typeof runWranglerRollout;
+    readonly runWranglerDeploymentStatus: typeof runWranglerDeploymentStatus;
+    readonly waitForReadiness: (release: Release, signal: AbortSignal, version: string, worker: WorkerArtifact, workerName?: string) => Promise<void>;
+    readonly signingIdentity: typeof signingIdentity;
+}
+/** Deploy one stable Worker target and verify its exact serving implementation. */
+export declare function deployCloudflare(parameters: CloudflareParams, context: DeployContext, dependencies: CloudflareDeployDependencies): Promise<DeployResult>;