@astrale-os/adapter-cloudflare 0.5.0-beta.4 → 0.5.0-beta.41

package/dist/build/wrangler/status.js

@@ -0,0 +1,56 @@
+import { runCapture, wranglerCommand } from './process.js';
+export async function runWranglerDeploymentStatus(args) {
+    const { cmd, prefix } = wranglerCommand(args.projectDir);
+    const result = await runCapture(cmd, [
+        ...prefix,
+        'deployments',
+        'status',
+        '--config',
+        args.configPath,
+        '--name',
+        args.workerName,
+        '--json',
+    ], args.projectDir, undefined, args.signal);
+    if (result.code !== 0) {
+        throw new Error(`wrangler deployments status failed (code ${result.code}):\n${result.out.slice(-2000)}`);
+    }
+    return admitWranglerDeploymentStatus(result.stdout);
+}
+export function admitWranglerDeploymentStatus(output) {
+    let decoded;
+    try {
+        decoded = JSON.parse(output);
+    }
+    catch (cause) {
+        throw new TypeError('wrangler deployments status returned invalid JSON.', { cause });
+    }
+    if (decoded === null || typeof decoded !== 'object' || Array.isArray(decoded))
+        invalidStatus();
+    const deployment = Reflect.get(decoded, 'id');
+    const traffic = Reflect.get(decoded, 'versions');
+    if (typeof deployment !== 'string' ||
+        deployment.length === 0 ||
+        !Array.isArray(traffic) ||
+        traffic.length === 0) {
+        invalidStatus();
+    }
+    const versions = traffic.map((entry) => {
+        if (entry === null || typeof entry !== 'object' || Array.isArray(entry))
+            invalidStatus();
+        const version = Reflect.get(entry, 'version_id');
+        const percentage = Reflect.get(entry, 'percentage');
+        if (typeof version !== 'string' ||
+            version.length === 0 ||
+            typeof percentage !== 'number' ||
+            !Number.isFinite(percentage) ||
+            percentage <= 0 ||
+            percentage > 100) {
+            invalidStatus();
+        }
+        return Object.freeze({ version, percentage });
+    });
+    return Object.freeze({ deployment, versions: Object.freeze(versions) });
+}
+function invalidStatus() {
+    throw new TypeError('wrangler deployments status returned invalid deployment evidence.');
+}

package/dist/build/wrangler/type-generation.d.ts

@@ -0,0 +1,6 @@
+export declare function runWranglerTypes(args: {
+    readonly projectDir: string;
+    readonly configPath: string;
+    readonly onLog?: (line: string) => void;
+    readonly signal?: AbortSignal;
+}): Promise<string>;

package/dist/build/wrangler/type-generation.js

@@ -0,0 +1,19 @@
+import { dirname, join } from 'node:path';
+import { runCapture, wranglerCommand } from './process.js';
+export async function runWranglerTypes(args) {
+    const { cmd, prefix } = wranglerCommand(args.projectDir);
+    const outputPath = join(dirname(args.configPath), 'worker-configuration.d.ts');
+    const { code, out } = await runCapture(cmd, [
+        ...prefix,
+        'types',
+        outputPath,
+        '--env-interface',
+        'CloudflareEnv',
+        '--config',
+        args.configPath,
+    ], args.projectDir, args.onLog, args.signal);
+    if (code !== 0) {
+        throw new Error(`wrangler types failed (code ${code}):\n${out.slice(-2000)}`);
+    }
+    return outputPath;
+}

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

@@ -1,86 +1,8 @@
-/**
- * Thin wrapper around the `wrangler` binary — the only place the adapter shells
- * out. `watch` runs `wrangler dev` (local workerd) and resolves once the worker
- * reports its local URL; `deploy` runs `wrangler deploy` and parses the
- * authoritative public URL from the output; secrets go through `wrangler secret
- * bulk`. The wrangler binary is resolved from the project's `node_modules/.bin`,
- * falling back to `npx wrangler`.
- */
-export interface DevHandle {
-    url: string;
-    stop(): Promise<void>;
-}
-export declare function runWranglerDev(args: {
-    projectDir: string;
-    configPath: string;
-    port: number;
-    remote: boolean;
-    /** Bind address — '0.0.0.0' for tunneled/proxied dev (`--host`). Default loopback. */
-    ip?: string;
-    /** When the port was NOT explicitly chosen, dodge a taken one automatically. */
-    autoPickPort?: boolean;
-    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 function runWranglerDeploy(args: DeployArgs & {
-    projectDir: string;
-}): Promise<{
-    url: string;
-    raw: 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;
-}>;
-/**
- * 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;
-}): Promise<void>;
-/**
- * Build the single-module worker bundle WITHOUT deploying — `wrangler deploy
- * --dry-run --outdir` (no Cloudflare auth required). Returns the path of the
- * bundled .js module (the managed adapter publishes its bytes).
- */
-export declare function runWranglerBundle(args: {
-    projectDir: string;
-    configPath: string;
-    outDir: string;
-    onLog?: (line: string) => void;
-}): Promise<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
+export { runWranglerBundle } from './wrangler/bundle.js';
+export { runWranglerDeploy, WranglerDeployError, type DeployArgs } from './wrangler/deploy.js';
+export { runWranglerDev, type DevHandle } from './wrangler/development.js';
+export { ensureWranglerDispatchNamespace, WranglerDispatchNamespaceError, } from './wrangler/namespace.js';
+export { wranglerProcessEnv } from './wrangler/process.js';
+export { runWranglerReleaseDeploy } from './wrangler/release.js';
+export { admitWranglerDeploymentStatus, runWranglerDeploymentStatus, type WranglerDeploymentStatus, } from './wrangler/status.js';
+export { runWranglerTypes } from './wrangler/type-generation.js';

package/dist/build/wrangler-cli.js

@@ -1,275 +1,8 @@
-/**
- * Thin wrapper around the `wrangler` binary — the only place the adapter shells
- * out. `watch` runs `wrangler dev` (local workerd) and resolves once the worker
- * reports its local URL; `deploy` runs `wrangler deploy` and parses the
- * authoritative public URL from the output; secrets go through `wrangler secret
- * bulk`. The wrangler binary is resolved from the project's `node_modules/.bin`,
- * falling back to `npx wrangler`.
- */
-import { spawn } from 'node:child_process';
-import { existsSync, readdirSync } from 'node:fs';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { createServer } from 'node:net';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { parseDeployUrl, parseDeployVersionId, parseDevReadyUrl } from './parse-output.js';
-function wranglerCommand(projectDir) {
-    const local = join(projectDir, 'node_modules', '.bin', 'wrangler');
-    if (existsSync(local))
-        return { cmd: local, prefix: [] };
-    return { cmd: 'npx', prefix: ['--yes', 'wrangler'] };
-}
-/**
- * True when `port` is free on `host`. A taken port previously made `wrangler
- * dev` either die ("Address already in use") or — worse — a FIRST probe hit a
- * DIFFERENT project's dev server on the same port (observed in agent runs:
- * every reader of the docs converges on 8787/8899).
- */
-function portFree(port, host) {
-    return new Promise((resolve) => {
-        const srv = createServer();
-        srv.once('error', () => resolve(false));
-        srv.once('listening', () => srv.close(() => resolve(true)));
-        srv.listen(port, host);
-    });
-}
-/** An OS-assigned free port. */
-function ephemeralPort(host) {
-    return new Promise((resolve, reject) => {
-        const srv = createServer();
-        srv.once('error', reject);
-        srv.listen(0, host, () => {
-            const addr = srv.address();
-            const port = typeof addr === 'object' && addr ? addr.port : 0;
-            srv.close(() => resolve(port));
-        });
-    });
-}
-export async function runWranglerDev(args) {
-    await runWranglerTypes(args);
-    const { cmd, prefix } = wranglerCommand(args.projectDir);
-    const bindHost = args.ip ?? '127.0.0.1';
-    if (args.autoPickPort && !(await portFree(args.port, bindHost))) {
-        const picked = await ephemeralPort(bindHost);
-        args.onLog?.(`port ${args.port} is taken — using ${picked} instead (pass --port to pin one)`);
-        args = { ...args, port: picked };
-    }
-    const wranglerArgs = [
-        ...prefix,
-        'dev',
-        '--config',
-        args.configPath,
-        '--port',
-        String(args.port),
-        '--local-protocol',
-        'http',
-        '--ip',
-        args.ip ?? '127.0.0.1',
-        ...(args.remote ? ['--remote'] : []),
-    ];
-    const child = spawn(cmd, wranglerArgs, {
-        cwd: args.projectDir,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        env: { ...process.env, WRANGLER_SEND_METRICS: 'false' },
-    });
-    const fallbackUrl = `http://localhost:${args.port}`;
-    // (args.port may have been re-picked above — everything below reads args.port)
-    let resolved = false;
-    // Wrangler's watch mode STAYS ALIVE on a build failure (listener up, worker
-    // never answers) — the classic silent hang. Track build errors so the
-    // safety net can fail LOUD instead of resolving a dead URL.
-    let buildErrorTail = '';
-    let outputTail = '';
-    const url = await new Promise((resolve, reject) => {
-        const onData = (buf) => {
-            const text = buf.toString();
-            outputTail = (outputTail + text).slice(-3000);
-            for (const line of text.split('\n')) {
-                if (line.trim())
-                    args.onLog?.(line);
-            }
-            if (/✘ \[ERROR\]|Build failed|Could not resolve "/.test(text)) {
-                buildErrorTail = (buildErrorTail + text).slice(-2000);
-            }
-            if (!resolved) {
-                const ready = parseDevReadyUrl(text, args.port);
-                if (ready) {
-                    resolved = true;
-                    resolve(ready);
-                }
-            }
-            else if (/Reloading|Detected changes|Updated/i.test(text)) {
-                args.onReload();
-            }
-        };
-        child.stdout?.on('data', onData);
-        child.stderr?.on('data', onData);
-        child.on('exit', (code) => {
-            if (!resolved) {
-                resolved = true;
-                reject(new Error(`wrangler dev exited before becoming ready (code ${code ?? 'null'}).\n${outputTail}`));
-            }
-        });
-        child.on('error', (err) => {
-            if (!resolved) {
-                resolved = true;
-                reject(err);
-            }
-        });
-        // Safety net: if we never matched a URL but the process is alive, assume the
-        // conventional localhost URL after a grace period — UNLESS the build
-        // failed, in which case a listener may be up but the worker will never
-        // answer: fail loud with the build output instead of handing back a dead
-        // URL.
-        setTimeout(() => {
-            if (!resolved && child.exitCode === null) {
-                resolved = true;
-                if (buildErrorTail) {
-                    void stopChild(child);
-                    reject(new Error(`worker build failed — the dev server would hang silently.\n${buildErrorTail}`));
-                }
-                else {
-                    resolve(fallbackUrl);
-                }
-            }
-        }, 15_000).unref?.();
-    });
-    return { url, stop: () => stopChild(child) };
-}
-export async function runWranglerDeploy(args) {
-    await runWranglerTypes(args);
-    const { cmd, prefix } = wranglerCommand(args.projectDir);
-    const deploy = (configPath) => runCapture(cmd, [...prefix, 'deploy', '--config', configPath], args.projectDir, args.onLog);
-    return deployWithSelfFallback(deploy, args);
-}
-/**
- * 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 async function deployWithSelfFallback(deploy, args) {
-    let { code, out } = await deploy(args.configPath);
-    if (code !== 0 && args.fallbackConfigPath && isSelfBindingMissing(out, args.workerName)) {
-        args.onLog?.('SELF service binding not resolvable yet (first deploy) — creating the worker, then re-binding SELF');
-        const first = await deploy(args.fallbackConfigPath);
-        if (first.code !== 0) {
-            throw new Error(`wrangler deploy (no-self pass) failed (code ${first.code}):\n${first.out.slice(-2000)}`);
-        }
-        ;
-        ({ code, out } = await deploy(args.configPath));
-    }
-    if (code !== 0) {
-        throw new Error(`wrangler deploy failed (code ${code}):\n${out.slice(-2000)}`);
-    }
-    const url = parseDeployUrl(out, args.route);
-    if (!url) {
-        throw new Error(`could not determine deployed URL from wrangler output:\n${out.slice(-2000)}`);
-    }
-    const deploymentVersion = parseDeployVersionId(out);
-    return { url, raw: out, ...(deploymentVersion === undefined ? {} : { deploymentVersion }) };
-}
-/**
- * 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 function isSelfBindingMissing(out, workerName) {
-    const bindingError = /could not resolve binding/i.test(out) ||
-        /service\b[^\n]*\bnot found/i.test(out) ||
-        /script\b[^\n]*\bnot found/i.test(out);
-    if (!bindingError || !/\bSELF\b/.test(out))
-        return false;
-    return workerName ? out.includes(workerName) : true;
-}
-export async function bulkPutSecrets(args) {
-    const names = Object.keys(args.secrets);
-    if (names.length === 0)
-        return;
-    const { cmd, prefix } = wranglerCommand(args.projectDir);
-    const dir = await mkdtemp(join(tmpdir(), 'astrale-secrets-'));
-    const file = join(dir, 'secrets.json');
-    try {
-        await writeFile(file, JSON.stringify(args.secrets));
-        const { code, out } = await runCapture(cmd, [...prefix, 'secret', 'bulk', file, '--config', args.configPath], args.projectDir, args.onLog);
-        if (code !== 0) {
-            throw new Error(`wrangler secret bulk failed (code ${code}):\n${out.slice(-1500)}`);
-        }
-    }
-    finally {
-        await rm(dir, { recursive: true, force: true });
-    }
-}
-// ── internals ──────────────────────────────────────────────────────────────
-function runCapture(cmd, args, cwd, onLog) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(cmd, args, {
-            cwd,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            env: { ...process.env, WRANGLER_SEND_METRICS: 'false' },
-        });
-        let out = '';
-        const onData = (buf) => {
-            const text = buf.toString();
-            out += text;
-            for (const line of text.split('\n'))
-                if (line.trim())
-                    onLog?.(line);
-        };
-        child.stdout?.on('data', onData);
-        child.stderr?.on('data', onData);
-        child.on('exit', (code) => resolve({ code: code ?? 1, out }));
-        child.on('error', reject);
-    });
-}
-async function stopChild(child) {
-    if (child.exitCode !== null)
-        return;
-    await new Promise((resolve) => {
-        child.on('exit', () => resolve());
-        child.kill('SIGTERM');
-        setTimeout(() => {
-            if (child.exitCode === null)
-                child.kill('SIGKILL');
-            resolve();
-        }, 4000).unref?.();
-    });
-}
-/**
- * Build the single-module worker bundle WITHOUT deploying — `wrangler deploy
- * --dry-run --outdir` (no Cloudflare auth required). Returns the path of the
- * bundled .js module (the managed adapter publishes its bytes).
- */
-export async function runWranglerBundle(args) {
-    await runWranglerTypes(args);
-    const { cmd, prefix } = wranglerCommand(args.projectDir);
-    const { code, out } = await runCapture(cmd, [...prefix, 'deploy', '--dry-run', '--outdir', args.outDir, '--config', args.configPath], args.projectDir, args.onLog);
-    if (code !== 0)
-        throw new Error(`wrangler bundle failed (exit ${code}): ${out.slice(-400)}`);
-    const js = readdirSync(args.outDir).filter((f) => f.endsWith('.js'));
-    if (js.length === 0)
-        throw new Error(`wrangler bundle produced no .js in ${args.outDir}`);
-    const preferred = js.find((f) => f.startsWith('worker')) ?? js[0];
-    return join(args.outDir, preferred);
-}
-/** Generate the exact binding and runtime types selected by the generated config. */
-export async function runWranglerTypes(args) {
-    const { cmd, prefix } = wranglerCommand(args.projectDir);
-    const outputPath = join(dirname(args.configPath), 'worker-configuration.d.ts');
-    const { code, out } = await runCapture(cmd, [
-        ...prefix,
-        'types',
-        outputPath,
-        '--env-interface',
-        'CloudflareEnv',
-        '--config',
-        args.configPath,
-    ], args.projectDir, args.onLog);
-    if (code !== 0) {
-        throw new Error(`wrangler types failed (code ${code}):\n${out.slice(-2000)}`);
-    }
-    return outputPath;
-}
-//# sourceMappingURL=wrangler-cli.js.map
+export { runWranglerBundle } from './wrangler/bundle.js';
+export { runWranglerDeploy, WranglerDeployError } from './wrangler/deploy.js';
+export { runWranglerDev } from './wrangler/development.js';
+export { ensureWranglerDispatchNamespace, WranglerDispatchNamespaceError, } from './wrangler/namespace.js';
+export { wranglerProcessEnv } from './wrangler/process.js';
+export { runWranglerReleaseDeploy } from './wrangler/release.js';
+export { admitWranglerDeploymentStatus, runWranglerDeploymentStatus, } from './wrangler/status.js';
+export { runWranglerTypes } from './wrangler/type-generation.js';

package/dist/cloudflare.d.ts

@@ -1,34 +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 { CloudflareParams } from './params.js';
-import { bulkPutSecrets, buildCloudflareWorker, buildFrontend, logTo, prepare, runWranglerDeploy, runWranglerDev, runWranglerTypes, watchFrontend } 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 watchFrontend: typeof watchFrontend;
-    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 health endpoint returns exactly 200.
- */
-declare function waitUntilLive(url: string, onLog: (line: string) => void, expectedDeploymentVersion?: string, timeoutMs?: number): Promise<void>;
-export {};
-//# sourceMappingURL=cloudflare.d.ts.map
+export { cloudflare } from './adapter.js';