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

package/dist/build/wrangler-cli.js

@@ -8,16 +8,32 @@
  */
 import { spawn } from 'node:child_process';
 import { existsSync, readdirSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
 import { createServer } from 'node:net';
 import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } 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'] };
+    const require = createRequire(import.meta.url);
+    const packagePath = require.resolve('wrangler/package.json');
+    const manifest = JSON.parse(readFileSync(packagePath, 'utf8'));
+    const executable = typeof manifest.bin === 'string' ? manifest.bin : manifest.bin?.wrangler;
+    if (!executable)
+        throw new TypeError('Installed Wrangler package has no wrangler executable.');
+    return { cmd: process.execPath, prefix: [resolve(dirname(packagePath), executable)] };
+}
+/** Keep Wrangler CLI diagnostic logs inside the generated project state. */
+export function wranglerProcessEnv(projectDir) {
+    return {
+        ...process.env,
+        WRANGLER_SEND_METRICS: 'false',
+        WRANGLER_LOG_PATH: process.env.WRANGLER_LOG_PATH || resolve(projectDir, '.astrale', 'logs', 'wrangler'),
+    };
 }
 /**
  * True when `port` is free on `host`. A taken port previously made `wrangler
@@ -54,6 +70,7 @@ export async function runWranglerDev(args) {
         args.onLog?.(`port ${args.port} is taken — using ${picked} instead (pass --port to pin one)`);
         args = { ...args, port: picked };
     }
+    const secretEnvironment = await createSecretEnvironment(args.secrets);
     const wranglerArgs = [
         ...prefix,
         'dev',
@@ -65,13 +82,21 @@ export async function runWranglerDev(args) {
         'http',
         '--ip',
         args.ip ?? '127.0.0.1',
+        ...(secretEnvironment === undefined ? [] : ['--env-file', secretEnvironment.path]),
         ...(args.remote ? ['--remote'] : []),
     ];
-    const child = spawn(cmd, wranglerArgs, {
-        cwd: args.projectDir,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        env: { ...process.env, WRANGLER_SEND_METRICS: 'false' },
-    });
+    let child;
+    try {
+        child = spawn(cmd, wranglerArgs, {
+            cwd: args.projectDir,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: wranglerProcessEnv(args.projectDir),
+        });
+    }
+    catch (cause) {
+        await secretEnvironment?.remove();
+        throw cause;
+    }
     const fallbackUrl = `http://localhost:${args.port}`;
     // (args.port may have been re-picked above — everything below reads args.port)
     let resolved = false;
@@ -80,135 +105,272 @@ export async function runWranglerDev(args) {
     // 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) {
+    let url;
+    try {
+        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;
-                    resolve(ready);
+                    reject(new Error(`wrangler dev exited before becoming ready (code ${code ?? 'null'}).\n${outputTail}`));
                 }
-            }
-            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}`));
+            });
+            child.on('error', (err) => {
+                if (!resolved) {
+                    resolved = true;
+                    reject(err);
                 }
-                else {
-                    resolve(fallbackUrl);
+            });
+            // 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?.();
+        });
+    }
+    catch (cause) {
+        await stopChild(child);
+        await secretEnvironment?.remove();
+        throw cause;
+    }
+    return {
+        url,
+        async stop() {
+            try {
+                await stopChild(child);
             }
-        }, 15_000).unref?.();
-    });
-    return { url, stop: () => stopChild(child) };
+            finally {
+                await secretEnvironment?.remove();
+            }
+        },
+    };
+}
+export class WranglerDeployError extends Error {
+    applied;
+    constructor(message, applied) {
+        super(message);
+        this.name = 'WranglerDeployError';
+        if (applied !== undefined)
+            this.applied = Object.freeze({ ...applied });
+    }
 }
 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));
-    }
+    const { code, out } = await runCapture(cmd, [...prefix, 'deploy', '--config', args.configPath], args.projectDir, args.onLog);
+    const url = parseDeployUrl(out, args.route);
+    const deploymentVersion = parseDeployVersionId(out);
     if (code !== 0) {
-        throw new Error(`wrangler deploy failed (code ${code}):\n${out.slice(-2000)}`);
+        throw new WranglerDeployError(`wrangler deploy failed (code ${code}):\n${out.slice(-2000)}`, url === undefined && deploymentVersion === undefined
+            ? undefined
+            : {
+                ...(url === undefined ? {} : { url }),
+                ...(deploymentVersion === undefined ? {} : { deploymentVersion }),
+            });
     }
-    const url = parseDeployUrl(out, args.route);
-    if (!url) {
-        throw new Error(`could not determine deployed URL from wrangler output:\n${out.slice(-2000)}`);
+    if (deploymentVersion === undefined) {
+        throw new WranglerDeployError('wrangler deploy did not report its Version ID.', url === undefined ? undefined : { url });
     }
-    const deploymentVersion = parseDeployVersionId(out);
-    return { url, raw: out, ...(deploymentVersion === undefined ? {} : { deploymentVersion }) };
+    return Object.freeze({
+        raw: out,
+        ...(url === undefined ? {} : { url }),
+        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;
+/** Upload one Schema-revision Worker without assigning it a public route. */
+export async function runWranglerReleaseDeploy(args) {
+    await runWranglerTypes(args);
+    const { cmd, prefix } = wranglerCommand(args.projectDir);
+    const execute = async (secretsFile) => runCapture(cmd, [
+        ...prefix,
+        'deploy',
+        '--config',
+        args.configPath,
+        '--dispatch-namespace',
+        args.namespace,
+        ...(secretsFile === undefined ? [] : ['--secrets-file', secretsFile]),
+    ], args.projectDir, args.onLog);
+    const result = await withSecretsFile(args.secrets, execute);
+    const deploymentVersion = parseDeployVersionId(result.out);
+    if (result.code !== 0) {
+        throw new WranglerDeployError(`wrangler Release deploy failed (code ${result.code}):\n${result.out.slice(-2000)}`, deploymentVersion === undefined ? undefined : { deploymentVersion });
+    }
+    if (deploymentVersion === undefined) {
+        throw new WranglerDeployError('wrangler Release deploy did not report its Version ID.');
+    }
+    return Object.freeze({ raw: result.out, deploymentVersion });
+}
+const MISSING_DISPATCH_NAMESPACE = /\[code:\s*100119\]/u;
+export class WranglerDispatchNamespaceError extends Error {
+    effect;
+    constructor(message, effect) {
+        super(message);
+        this.name = 'WranglerDispatchNamespaceError';
+        this.effect = effect;
+    }
 }
-export async function bulkPutSecrets(args) {
-    const names = Object.keys(args.secrets);
-    if (names.length === 0)
+/** Establish the private dispatch namespace without advancing the public gateway. */
+export async function ensureWranglerDispatchNamespace(args) {
+    const { cmd, prefix } = wranglerCommand(args.projectDir);
+    const inspect = () => runCapture(cmd, [...prefix, 'dispatch-namespace', 'get', args.namespace], args.projectDir, args.onLog);
+    const observed = await inspect();
+    if (observed.code === 0)
+        return;
+    if (!MISSING_DISPATCH_NAMESPACE.test(observed.out)) {
+        throw new WranglerDispatchNamespaceError(`wrangler dispatch namespace inspection failed (code ${observed.code}):\n${observed.out.slice(-2000)}`, 'none');
+    }
+    const created = await runCapture(cmd, [...prefix, 'dispatch-namespace', 'create', args.namespace], args.projectDir, args.onLog);
+    if (created.code === 0)
         return;
+    // Another convergent deployment may have created the namespace after inspection.
+    if ((await inspect()).code === 0)
+        return;
+    throw new WranglerDispatchNamespaceError(`wrangler dispatch namespace creation failed (code ${created.code}):\n${created.out.slice(-2000)}`, 'unknown');
+}
+export async function runWranglerDeploymentStatus(args) {
     const { cmd, prefix } = wranglerCommand(args.projectDir);
-    const dir = await mkdtemp(join(tmpdir(), 'astrale-secrets-'));
-    const file = join(dir, 'secrets.json');
+    const result = await runCapture(cmd, [
+        ...prefix,
+        'deployments',
+        'status',
+        '--config',
+        args.configPath,
+        '--name',
+        args.workerName,
+        '--json',
+    ], args.projectDir);
+    if (result.code !== 0) {
+        throw new Error(`wrangler deployments status failed (code ${result.code}):\n${result.out.slice(-2000)}`);
+    }
+    return admitWranglerDeploymentStatus(result.out);
+}
+/** Admit Wrangler's current-deployment JSON before it becomes provider evidence. */
+export function admitWranglerDeploymentStatus(output) {
+    let decoded;
     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)}`);
+        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.');
+}
+async function withSecretsFile(secrets, operation) {
+    if (Object.keys(secrets).length === 0)
+        return operation();
+    const directory = await mkdtemp(join(tmpdir(), 'astrale-secrets-'));
+    const path = join(directory, 'secrets.json');
+    try {
+        await writeFile(path, JSON.stringify(secrets), { mode: 0o600 });
+        return await operation(path);
     }
     finally {
-        await rm(dir, { recursive: true, force: true });
+        await rm(directory, { recursive: true, force: true });
     }
 }
+async function createSecretEnvironment(secrets) {
+    if (Object.keys(secrets).length === 0)
+        return undefined;
+    const source = Object.entries(secrets)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, value]) => `${secretName(name)}=${dotenvSecret(value)}`)
+        .join('\n');
+    const directory = await mkdtemp(join(tmpdir(), 'astrale-dev-secrets-'));
+    const path = join(directory, '.dev.vars');
+    await writeFile(path, `${source}\n`, { mode: 0o600 });
+    return Object.freeze({
+        path,
+        remove: () => rm(directory, { recursive: true, force: true }),
+    });
+}
+function secretName(input) {
+    if (!/^[A-Za-z_]\w*$/u.test(input)) {
+        throw new TypeError(`Cloudflare secret name '${input}' is not a Worker binding name.`);
+    }
+    return input;
+}
+/** Encode without changing a byte under Wrangler's dotenv boundary. */
+function dotenvSecret(input) {
+    if (!input.includes("'"))
+        return `'${input}'`;
+    if (!input.includes('`'))
+        return `\`${input}\``;
+    if (!input.includes('"') && !input.includes('\\n') && !input.includes('\\r')) {
+        return `"${input}"`;
+    }
+    if (input.trim() === input && !/[#\r\n]/u.test(input))
+        return input;
+    throw new TypeError('Cloudflare local secret cannot be represented losslessly as dotenv.');
+}
 // ── 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' },
+            env: wranglerProcessEnv(cwd),
         });
         let out = '';
         const onData = (buf) => {
@@ -245,14 +407,26 @@ async function stopChild(child) {
 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);
+    const { code, out } = await runCapture(cmd, [
+        ...prefix,
+        'deploy',
+        '--dry-run',
+        '--outdir',
+        args.outDir,
+        '--metafile',
+        '--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);
+    return Object.freeze({
+        bundlePath: join(args.outDir, preferred),
+        metafilePath: join(args.outDir, 'bundle-meta.json'),
+    });
 }
 /** Generate the exact binding and runtime types selected by the generated config. */
 export async function runWranglerTypes(args) {
@@ -272,4 +446,3 @@ export async function runWranglerTypes(args) {
     }
     return outputPath;
 }
-//# sourceMappingURL=wrangler-cli.js.map

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';