@astrale-os/adapter-cloudflare 0.5.0-beta.2 → 0.5.0-beta.21

package/dist/build/frontend-v1.js

@@ -0,0 +1,133 @@
+import { frontend as frontendBuild } from '@astrale-os/sdk/deployment/build';
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { readFile, readdir, rm } from 'node:fs/promises';
+import { createServer } from 'node:net';
+import { join } from 'node:path';
+export async function frontendFiles(input) {
+    const frontend = input.frontend;
+    if (frontend === undefined)
+        return [];
+    if (frontend.source.kind === 'external')
+        return frontendBuild.files(frontend, []);
+    const output = join(input.projectDir, '.astrale', 'frontend-build');
+    await rm(output, { recursive: true, force: true });
+    await run(viteCommand(input.projectDir), [
+        'build',
+        '--outDir',
+        output,
+        '--emptyOutDir',
+        ...(frontend.source.config === undefined ? [] : ['--config', frontend.source.config]),
+    ], input.projectDir, input.onLog);
+    return frontendBuild.files(frontend, await readFiles(output));
+}
+export async function startFrontend(input) {
+    const frontend = input.frontend;
+    if (frontend === undefined || frontend.source.kind !== 'vite')
+        return undefined;
+    const port = await ephemeralPort();
+    const child = spawn(viteCommand(input.projectDir), [
+        '--host',
+        '127.0.0.1',
+        '--port',
+        String(port),
+        '--strictPort',
+        ...(frontend.source.config === undefined ? [] : ['--config', frontend.source.config]),
+    ], { cwd: input.projectDir, stdio: ['ignore', 'pipe', 'pipe'] });
+    const output = [];
+    const collect = (buffer) => {
+        for (const line of buffer.toString().split('\n')) {
+            if (line.trim() === '')
+                continue;
+            output.push(line);
+            if (output.length > 40)
+                output.shift();
+            input.onLog?.(line);
+        }
+    };
+    child.stdout?.on('data', collect);
+    child.stderr?.on('data', collect);
+    const url = `http://127.0.0.1:${port}`;
+    try {
+        await ready(url, child, output);
+    }
+    catch (cause) {
+        await stop(child);
+        throw cause;
+    }
+    return Object.freeze({ url, stop: () => stop(child) });
+}
+async function readFiles(root, current = '') {
+    const entries = await readdir(join(root, current), { withFileTypes: true });
+    const files = [];
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        const path = current === '' ? entry.name : `${current}/${entry.name}`;
+        if (entry.isDirectory())
+            files.push(...(await readFiles(root, path)));
+        else if (entry.isFile()) {
+            files.push({ path, content: new Uint8Array(await readFile(join(root, path))) });
+        }
+    }
+    return files;
+}
+function viteCommand(projectDir) {
+    const command = join(projectDir, 'node_modules', '.bin', 'vite');
+    if (!existsSync(command))
+        throw new TypeError('Vite frontend requires a project-local vite binary.');
+    return command;
+}
+function run(command, args, cwd, onLog) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+        let output = '';
+        const collect = (buffer) => {
+            const value = buffer.toString();
+            output += value;
+            for (const line of value.split('\n'))
+                if (line.trim() !== '')
+                    onLog?.(line);
+        };
+        child.stdout?.on('data', collect);
+        child.stderr?.on('data', collect);
+        child.on('error', reject);
+        child.on('exit', (code) => code === 0
+            ? resolve()
+            : reject(new Error(`Vite failed (code ${code ?? 1}):\n${output.slice(-1500)}`)));
+    });
+}
+function ephemeralPort() {
+    return new Promise((resolve, reject) => {
+        const server = createServer();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address !== null ? address.port : 0;
+            server.close((cause) => (cause === undefined ? resolve(port) : reject(cause)));
+        });
+    });
+}
+async function ready(url, child, output) {
+    const deadline = Date.now() + 15_000;
+    while (Date.now() < deadline) {
+        if (child.exitCode !== null) {
+            throw new Error(`Vite exited before readiness (code ${child.exitCode}).\n${output.join('\n')}`);
+        }
+        try {
+            const response = await fetch(url, { signal: AbortSignal.timeout(500) });
+            await response.body?.cancel();
+            return;
+        }
+        catch {
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+    }
+    throw new Error(`Vite did not become ready at ${url}.`);
+}
+function stop(child) {
+    if (child.exitCode !== null || child.killed)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        child.once('exit', () => resolve());
+        child.kill('SIGTERM');
+    });
+}

package/dist/build/index.d.ts

@@ -1,16 +1,8 @@
-/**
- * `@astrale-os/adapter-cloudflare/build` — the shared Cloudflare-Workers build
- * toolkit, exposed for sibling deploy adapters (e.g.
- * `@astrale-os/adapter-astrale`).
- *
- * This is the "compile a `defineDomain` into a Cloudflare Workers bundle + run
- * local dev" surface that every Cloudflare-Workers deploy strategy shares,
- * regardless of WHERE the bundle ultimately ships. It is NOT part of the public
- * adapter API (`@astrale-os/adapter-cloudflare`) — it's the seam two adapters
- * build on so the codegen/bundling/dev logic lives in exactly one place.
- */
-export { buildFrontend, FRONTEND_STAGE_DIR, watchFrontend, type FrontendWatchHandle, type FrontendWatchSubscribe, type FrontendWatchSubscription, } from './frontend.js';
-export { logTo, prepare } from './prepare.js';
-export { buildCloudflareWorker, type CloudflareWorkerBuild } from './worker.js';
-export { bulkPutSecrets, runWranglerBundle, runWranglerDeploy, runWranglerDev, runWranglerTypes, } from './wrangler-cli.js';
-//# sourceMappingURL=index.d.ts.map
+export { artifact, materialize } from './artifact.js';
+export { resolveRouter, workerName } from './configuration.js';
+export { frontendFiles, startFrontend, type FrontendDevHandle } from './frontend-v1.js';
+export { qualifyWorkerBundle } from './qualification.js';
+export { assertSingletonRuntimeRoots } from './roots.js';
+export { signingIdentity } from '../identity/source.js';
+export { signingIdentitySecrets } from '../identity/secret.js';
+export { runWranglerBundle, runWranglerDeploy, runWranglerDeploymentStatus, runWranglerDev, runWranglerTypes, } from './wrangler-cli.js';

package/dist/build/index.js

@@ -1,16 +1,8 @@
-/**
- * `@astrale-os/adapter-cloudflare/build` — the shared Cloudflare-Workers build
- * toolkit, exposed for sibling deploy adapters (e.g.
- * `@astrale-os/adapter-astrale`).
- *
- * This is the "compile a `defineDomain` into a Cloudflare Workers bundle + run
- * local dev" surface that every Cloudflare-Workers deploy strategy shares,
- * regardless of WHERE the bundle ultimately ships. It is NOT part of the public
- * adapter API (`@astrale-os/adapter-cloudflare`) — it's the seam two adapters
- * build on so the codegen/bundling/dev logic lives in exactly one place.
- */
-export { buildFrontend, FRONTEND_STAGE_DIR, watchFrontend, } from './frontend.js';
-export { logTo, prepare } from './prepare.js';
-export { buildCloudflareWorker } from './worker.js';
-export { bulkPutSecrets, runWranglerBundle, runWranglerDeploy, runWranglerDev, runWranglerTypes, } from './wrangler-cli.js';
-//# sourceMappingURL=index.js.map
+export { artifact, materialize } from './artifact.js';
+export { resolveRouter, workerName } from './configuration.js';
+export { frontendFiles, startFrontend } from './frontend-v1.js';
+export { qualifyWorkerBundle } from './qualification.js';
+export { assertSingletonRuntimeRoots } from './roots.js';
+export { signingIdentity } from '../identity/source.js';
+export { signingIdentitySecrets } from '../identity/secret.js';
+export { runWranglerBundle, runWranglerDeploy, runWranglerDeploymentStatus, runWranglerDev, runWranglerTypes, } from './wrangler-cli.js';

package/dist/build/metafile.d.ts

@@ -0,0 +1,5 @@
+export interface WranglerMetafile {
+    readonly inputs: Readonly<Record<string, unknown>>;
+}
+/** Decode Wrangler's emitted esbuild graph at the provider-tooling boundary. */
+export declare function readWranglerMetafile(path: string): Promise<WranglerMetafile>;

package/dist/build/metafile.js

@@ -0,0 +1,14 @@
+import { readFile } from 'node:fs/promises';
+/** Decode Wrangler's emitted esbuild graph at the provider-tooling boundary. */
+export async function readWranglerMetafile(path) {
+    const source = await readFile(path, 'utf8');
+    const value = JSON.parse(source);
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new TypeError('Wrangler metafile is not an object.');
+    }
+    const inputs = Reflect.get(value, 'inputs');
+    if (inputs === null || typeof inputs !== 'object' || Array.isArray(inputs)) {
+        throw new TypeError('Wrangler metafile has no input graph.');
+    }
+    return Object.freeze({ inputs: inputs });
+}

package/dist/build/parse-output.d.ts

@@ -24,4 +24,3 @@ export declare function parseDeployUrl(text: string, route?: string): string | u
 export declare function parseDeployVersionId(text: string): string | undefined;
 /** Normalize a local dev URL to an origin: `0.0.0.0` → `localhost`, fill the port. */
 export declare function normalizeLocal(url: string, port: number): string;
-//# sourceMappingURL=parse-output.d.ts.map

package/dist/build/parse-output.js

@@ -55,4 +55,3 @@ export function normalizeLocal(url, port) {
         return `http://localhost:${port}`;
     }
 }
-//# sourceMappingURL=parse-output.js.map

package/dist/build/qualification.d.ts

@@ -0,0 +1,5 @@
+/** Qualify Wrangler's emitted module, not generated source or an inferred graph. */
+export declare function qualifyWorkerBundle(evidence: {
+    readonly metafilePath: string;
+    readonly inputRoot: string;
+}): Promise<void>;

package/dist/build/qualification.js

@@ -0,0 +1,7 @@
+import { assertRuntimeClosure } from './closure.js';
+import { assertSingletonRuntimeRoots } from './roots.js';
+/** Qualify Wrangler's emitted module, not generated source or an inferred graph. */
+export async function qualifyWorkerBundle(evidence) {
+    await assertRuntimeClosure(evidence.metafilePath);
+    await assertSingletonRuntimeRoots(evidence.metafilePath, evidence.inputRoot);
+}

package/dist/build/roots.d.ts

@@ -0,0 +1,2 @@
+/** Prove that Wrangler emitted at most one physical root per runtime package. */
+export declare function assertSingletonRuntimeRoots(metafilePath: string, inputRoot: string): Promise<void>;

package/dist/build/roots.js

@@ -0,0 +1,34 @@
+import { realpath } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { readWranglerMetafile } from './metafile.js';
+const RUNTIME_PACKAGES = [
+    '@astrale-os/adapter-cloudflare',
+    '@astrale-os/sdk',
+    '@astrale-os/kernel-core',
+    '@astrale-os/kernel-dsl',
+    '@astrale-os/kernel-ports',
+    '@astrale-os/kernel-protocol',
+    '@astrale-os/kernel-server',
+    '@astrale-os/kernel-client',
+];
+/** Prove that Wrangler emitted at most one physical root per runtime package. */
+export async function assertSingletonRuntimeRoots(metafilePath, inputRoot) {
+    const metafile = await readWranglerMetafile(metafilePath);
+    for (const name of RUNTIME_PACKAGES) {
+        const roots = new Set();
+        for (const input of Object.keys(metafile.inputs)) {
+            const root = packageRoot(input, name);
+            if (root !== undefined)
+                roots.add(await realpath(resolve(inputRoot, root)));
+        }
+        if (roots.size > 1) {
+            throw new Error(`Cloudflare Worker contains duplicate physical ${name} roots: ${[...roots].join(', ')}.`);
+        }
+    }
+}
+function packageRoot(input, name) {
+    const normalized = input.replaceAll('\\', '/');
+    const marker = `node_modules/${name}/`;
+    const index = normalized.lastIndexOf(marker);
+    return index < 0 ? undefined : normalized.slice(0, index + marker.length - 1);
+}

package/dist/build/wrangler-cli.d.ts

@@ -6,6 +6,8 @@
  * bulk`. The wrangler binary is resolved from the project's `node_modules/.bin`,
  * falling back to `npx wrangler`.
  */
+/** Keep Wrangler CLI diagnostic logs inside the generated project state. */
+export declare function wranglerProcessEnv(projectDir: string): NodeJS.ProcessEnv;
 export interface DevHandle {
     url: string;
     stop(): Promise<void>;
@@ -19,53 +21,68 @@ export declare function runWranglerDev(args: {
     ip?: string;
     /** When the port was NOT explicitly chosen, dodge a taken one automatically. */
     autoPickPort?: boolean;
+    /** Secret bindings loaded through Wrangler's dotenv boundary, never config vars. */
+    secrets: Readonly<Record<string, string>>;
     onReload: () => void;
     onLog?: (line: string) => void;
 }): Promise<DevHandle>;
 export interface DeployArgs {
     configPath: string;
-    /** SELF-less config for the first-deploy two-pass (see `deployWithSelfFallback`). */
-    fallbackConfigPath?: string;
-    /** The worker's own name, to scope the self-binding-missing detection. */
-    workerName?: string;
     route?: string;
     onLog?: (line: string) => void;
 }
+export declare class WranglerDeployError extends Error {
+    readonly applied?: {
+        readonly url?: string;
+        readonly deploymentVersion?: string;
+    };
+    constructor(message: string, applied?: {
+        readonly url?: string;
+        readonly deploymentVersion?: string;
+    });
+}
 export declare function runWranglerDeploy(args: DeployArgs & {
     projectDir: string;
 }): Promise<{
-    url: string;
+    url?: string;
     raw: string;
-    deploymentVersion?: string;
+    deploymentVersion: string;
 }>;
-/**
- * Deploy with a one-time SELF-binding first-deploy recovery. A fresh worker that
- * declares a `services: SELF` binding can't deploy (its own script doesn't exist
- * yet); on THAT specific failure we deploy the SELF-less fallback to create the
- * script, then redeploy WITH SELF so autobinding works. Steady state (every
- * deploy after the first) is a single pass. The `deploy` runner is injected so
- * the orchestration is unit-testable without shelling out.
- */
-export declare function deployWithSelfFallback(deploy: (configPath: string) => Promise<{
-    code: number;
-    out: string;
-}>, args: DeployArgs): Promise<{
-    url: string;
-    raw: string;
-    deploymentVersion?: string;
+/** Upload one Schema-revision Worker without assigning it a public route. */
+export declare function runWranglerReleaseDeploy(args: {
+    readonly projectDir: string;
+    readonly configPath: string;
+    readonly namespace: string;
+    readonly secrets: Readonly<Record<string, string>>;
+    readonly onLog?: (line: string) => void;
+}): Promise<{
+    readonly raw: string;
+    readonly deploymentVersion: string;
 }>;
-/**
- * True when wrangler failed specifically because the worker's OWN `SELF` service
- * binding can't resolve yet (first deploy of a fresh script). Requires the
- * worker name so an unrelated missing-service error doesn't trigger the two-pass.
- */
-export declare function isSelfBindingMissing(out: string, workerName?: string): boolean;
-export declare function bulkPutSecrets(args: {
-    projectDir: string;
-    configPath: string;
-    secrets: Record<string, string>;
-    onLog?: (line: string) => void;
+export declare class WranglerDispatchNamespaceError extends Error {
+    readonly effect: 'none' | 'unknown';
+    constructor(message: string, effect: 'none' | 'unknown');
+}
+/** Establish the private dispatch namespace without advancing the public gateway. */
+export declare function ensureWranglerDispatchNamespace(args: {
+    readonly projectDir: string;
+    readonly namespace: string;
+    readonly onLog?: (line: string) => void;
 }): Promise<void>;
+export declare function runWranglerDeploymentStatus(args: {
+    readonly projectDir: string;
+    readonly configPath: string;
+    readonly workerName: string;
+}): Promise<WranglerDeploymentStatus>;
+export interface WranglerDeploymentStatus {
+    readonly deployment: string;
+    readonly versions: readonly {
+        readonly version: string;
+        readonly percentage: number;
+    }[];
+}
+/** Admit Wrangler's current-deployment JSON before it becomes provider evidence. */
+export declare function admitWranglerDeploymentStatus(output: string): WranglerDeploymentStatus;
 /**
  * Build the single-module worker bundle WITHOUT deploying — `wrangler deploy
  * --dry-run --outdir` (no Cloudflare auth required). Returns the path of the
@@ -76,11 +93,13 @@ export declare function runWranglerBundle(args: {
     configPath: string;
     outDir: string;
     onLog?: (line: string) => void;
-}): Promise<string>;
+}): Promise<{
+    readonly bundlePath: string;
+    readonly metafilePath: string;
+}>;
 /** Generate the exact binding and runtime types selected by the generated config. */
 export declare function runWranglerTypes(args: {
     readonly projectDir: string;
     readonly configPath: string;
     readonly onLog?: (line: string) => void;
 }): Promise<string>;
-//# sourceMappingURL=wrangler-cli.d.ts.map