@astrale-os/adapter-cloudflare 0.5.0-beta.8 → 0.5.0-beta.80

package/dist/worker/index.js

@@ -1,212 +1,2 @@
-import { issuer } from '@astrale-os/kernel-core/auth';
-import { createRemoteApplication } from '@astrale-os/sdk/server';
-import { Hono as HonoApplication } from 'hono';
-import { dispatchCloudflareRequest, prepareCloudflareRequest } from './fetch.js';
-const MAXIMUM_CACHED_APPLICATIONS = 4;
-const APPLICATION_CLOSE_TIMEOUT_MS = 5_000;
-/**
- * Compose one Cloudflare module Worker without request-global mutation.
- * Environment bindings are captured once per immutable serving URL/version generation.
- */
-export function cloudflareWorkerEntry() {
-    return function (config) {
-        const applications = new Map();
-        let resolvedDefinition = config.definition;
-        let pendingDefinition;
-        const definitionFor = async (bindings) => {
-            if (resolvedDefinition !== undefined)
-                return resolvedDefinition;
-            if (pendingDefinition !== undefined)
-                return pendingDefinition;
-            const resolve = config.resolveDefinition;
-            if (resolve === undefined)
-                throw new TypeError('Cloudflare Worker Domain definition is unavailable.');
-            const current = Promise.resolve().then(() => resolve(bindings));
-            pendingDefinition = current;
-            try {
-                const definition = await current;
-                resolvedDefinition = definition;
-                return definition;
-            }
-            finally {
-                if (pendingDefinition === current)
-                    pendingDefinition = undefined;
-            }
-        };
-        const applicationFor = async (url, bindings, definition) => {
-            const version = deploymentVersion(bindings);
-            const key = `${url}\u0000${version}`;
-            const cached = applications.get(key);
-            if (cached !== undefined)
-                return cached;
-            const environment = config.resolveEnvironment === undefined
-                ? bindings
-                : await config.resolveEnvironment(bindings);
-            const routedFetch = async (input, init) => {
-                const { request, rejectRedirect } = prepareCloudflareRequest(input, init);
-                const destination = new URL(request.url);
-                if (destination.origin === new URL(url).origin) {
-                    const self = config.selfBinding?.(bindings);
-                    return dispatchCloudflareRequest(request, rejectRedirect, (transportRequest) => self !== null && self !== undefined
-                        ? self.fetch(transportRequest)
-                        : serving.app.fetch(transportRequest, environment));
-                }
-                const route = config.routeSubrequest?.(destination, bindings);
-                return dispatchCloudflareRequest(request, rejectRedirect, (transportRequest) => route === null || route === undefined
-                    ? fetch(transportRequest)
-                    : route.fetch(transportRequest));
-            };
-            const deploymentQuery = `deployment=${encodeURIComponent(version)}`;
-            const issuerId = issuer.accept(url);
-            const host = new HonoApplication();
-            host.get('/meta', (context) => context.json({
-                origin: definition.schema.origin,
-                issuer: issuerId,
-                schemaRevision: definition.domain.$.revision,
-                deploymentVersion: version,
-            }));
-            const serving = createRemoteApplication({
-                definition,
-                environment,
-                identity: {
-                    issuer: issuerId,
-                    subject: definition.schema.origin,
-                    privateKey: typeof config.privateKey === 'function'
-                        ? config.privateKey(bindings)
-                        : config.privateKey,
-                    fetch: routedFetch,
-                    ...(new URL(url).protocol === 'http:' ? { allowInsecureHttp: true } : {}),
-                },
-                deployment: {
-                    bundleHref: `${url}/.well-known/astrale/domain.bundle.json?${deploymentQuery}`,
-                    endpoint: { http: `${url}/invoke` },
-                    ...(definition.frontend === undefined
-                        ? {}
-                        : { frontendBaseHref: url, frontendCacheKey: version }),
-                    ...(config.manifest === undefined ? {} : { manifest: config.manifest }),
-                    delivery: {
-                        href: `${url}/install`,
-                        method: 'POST',
-                        authentication: { kind: 'public' },
-                    },
-                },
-                app: host,
-                server: {
-                    path: '/invoke',
-                    health: { probe: { check: () => true } },
-                    limits: {
-                        maximumRequestBytes: 1024 * 1024,
-                        maximumPublicationBytes: 1024 * 1024,
-                        maximumBundleBytes: 8 * 1024 * 1024,
-                        maximumDeliveryBytes: 8 * 1024 * 1024,
-                        invocationTimeoutMs: config.invocationTimeoutMs ?? 30_000,
-                    },
-                },
-            });
-            const created = Object.freeze({
-                origin: new URL(url).origin,
-                application: serving,
-                environment,
-            });
-            if (applications.size >= MAXIMUM_CACHED_APPLICATIONS) {
-                const oldest = applications.keys().next().value;
-                if (oldest !== undefined) {
-                    const evicted = applications.get(oldest);
-                    applications.delete(oldest);
-                    if (evicted !== undefined) {
-                        try {
-                            await closeEvictedApplication(evicted.application);
-                        }
-                        catch (cause) {
-                            await serving
-                                .close({ deadline: Date.now() + APPLICATION_CLOSE_TIMEOUT_MS })
-                                .catch(() => undefined);
-                            throw cause;
-                        }
-                    }
-                }
-            }
-            applications.set(key, created);
-            return created;
-        };
-        return Object.freeze({
-            async fetch(request, bindings, executionContext) {
-                const requestUrl = new URL(request.url);
-                const definition = await definitionFor(bindings);
-                if (definition.frontend !== undefined) {
-                    const asset = await frontendAsset(definition, bindings, requestUrl, request);
-                    if (asset !== undefined)
-                        return asset;
-                }
-                const publicUrl = canonicalServingUrl(config.resolveUrl?.(bindings, requestOrigin(requestUrl, request)) ??
-                    bindings.WORKER_URL ??
-                    requestOrigin(requestUrl, request));
-                const serving = await applicationFor(publicUrl, bindings, definition);
-                return serving.application.app.fetch(request, serving.environment, executionContext);
-            },
-        });
-    };
-}
-/** Close an evicted Application before its environment bindings leave the cache. */
-export function closeEvictedApplication(application, now = Date.now) {
-    return application.close({ deadline: now() + APPLICATION_CLOSE_TIMEOUT_MS });
-}
-async function frontendAsset(definition, environment, url, request) {
-    const frontend = definition.frontend;
-    if (frontend === undefined || frontend.source.kind === 'external')
-        return undefined;
-    const routes = frontend.routes;
-    const route = Object.values(routes).find((candidate) => candidate.path === url.pathname);
-    const staticAsset = url.pathname.startsWith('/assets/');
-    if (route === undefined && !staticAsset)
-        return undefined;
-    if (request.method !== 'GET' && request.method !== 'HEAD')
-        return undefined;
-    const binding = environment.ASSETS;
-    if (binding === undefined)
-        return undefined;
-    const dev = environment.FRONTEND_DEV_URL?.replace(/\/+$/u, '');
-    if (dev !== undefined && dev.length > 0) {
-        return fetch(new Request(`${dev}${url.pathname}${url.search}`, request));
-    }
-    const path = route === undefined ? `${url.pathname}${url.search}` : `/${route.document}${url.search}`;
-    return binding.fetch(new Request(new URL(path, url.origin), request));
-}
-function requestOrigin(url, request) {
-    if (url.protocol !== 'http:')
-        return url.origin;
-    const forwarded = request.headers.get('x-forwarded-proto')?.split(',')[0]?.trim().toLowerCase();
-    return forwarded === 'https' ? `https://${url.host}` : url.origin;
-}
-function canonicalServingUrl(input) {
-    let url;
-    try {
-        url = new URL(input);
-    }
-    catch (cause) {
-        throw new TypeError('Cloudflare Worker serving URL is invalid.', { cause });
-    }
-    if ((url.protocol !== 'https:' && url.protocol !== 'http:') ||
-        url.username !== '' ||
-        url.password !== '' ||
-        url.pathname !== '/' ||
-        url.search !== '' ||
-        url.hash !== '') {
-        throw new TypeError('Cloudflare Worker serving URL must be one HTTP(S) origin.');
-    }
-    return url.origin;
-}
-function deploymentVersion(environment) {
-    const input = environment.ASTRALE_VERSION_METADATA;
-    if (input !== null &&
-        typeof input === 'object' &&
-        typeof input.id === 'string' &&
-        input.id.length > 0) {
-        return input.id;
-    }
-    const fallback = environment.ASTRALE_DEPLOYMENT_VERSION;
-    if (typeof fallback === 'string' && fallback.length > 0)
-        return fallback;
-    throw new TypeError('Cloudflare Worker deployment version is unavailable.');
-}
-//# sourceMappingURL=index.js.map
+export * from './entry.js';
+export { decodeSigningIdentity, runtimeBindings } from './identity.js';

package/dist/wrangler/bundle.d.ts

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

package/dist/wrangler/bundle.js

@@ -0,0 +1,27 @@
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { runCapture, wranglerCommand } from './process.js';
+export async function runWranglerBundle(args) {
+    const { cmd, prefix } = wranglerCommand(args.projectDir);
+    const { code, out } = await runCapture(cmd, [
+        ...prefix,
+        'deploy',
+        '--dry-run',
+        '--outdir',
+        args.outDir,
+        '--metafile',
+        '--config',
+        args.configPath,
+    ], args.projectDir, args.onLog, args.signal);
+    if (code !== 0)
+        throw new Error(`wrangler bundle failed (exit ${code}): ${out.slice(-400)}`);
+    const javascript = readdirSync(args.outDir).filter((file) => file.endsWith('.js'));
+    if (javascript.length === 0) {
+        throw new Error(`wrangler bundle produced no .js in ${args.outDir}`);
+    }
+    const preferred = javascript.find((file) => file.startsWith('worker')) ?? javascript[0];
+    return Object.freeze({
+        bundlePath: join(args.outDir, preferred),
+        metafilePath: join(args.outDir, 'bundle-meta.json'),
+    });
+}

package/dist/wrangler/deploy.d.ts

@@ -0,0 +1,24 @@
+export interface DeployArgs {
+    configPath: string;
+    secrets?: Readonly<Record<string, string>>;
+    route?: string;
+    onLog?: (line: string) => void;
+    signal?: AbortSignal;
+}
+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;
+    raw: string;
+    deploymentVersion: string;
+}>;

package/dist/wrangler/deploy.js

@@ -0,0 +1,44 @@
+import { parseDeployUrl, parseDeployVersionId } from '../deploy/output.js';
+import { runCapture, wranglerCommand } from './process.js';
+import { secretRedactor, withSecretsFile } from './secrets.js';
+import { runWranglerTypes } from './type-generation.js';
+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 secrets = args.secrets ?? {};
+    const execute = (secretsFile) => runCapture(cmd, [
+        ...prefix,
+        'deploy',
+        '--config',
+        args.configPath,
+        ...(secretsFile === undefined ? [] : ['--secrets-file', secretsFile]),
+    ], args.projectDir, args.onLog, args.signal, secretRedactor(secrets));
+    const { code, out } = await withSecretsFile(secrets, execute);
+    const url = parseDeployUrl(out, args.route);
+    const deploymentVersion = parseDeployVersionId(out);
+    if (code !== 0) {
+        throw new WranglerDeployError(`wrangler deploy failed (code ${code}):\n${out.slice(-2000)}`, url === undefined && deploymentVersion === undefined
+            ? undefined
+            : {
+                ...(url === undefined ? {} : { url }),
+                ...(deploymentVersion === undefined ? {} : { deploymentVersion }),
+            });
+    }
+    if (deploymentVersion === undefined) {
+        throw new WranglerDeployError('wrangler deploy did not report its Version ID.', url === undefined ? undefined : { url });
+    }
+    return Object.freeze({
+        raw: out,
+        ...(url === undefined ? {} : { url }),
+        deploymentVersion,
+    });
+}

package/dist/wrangler/index.d.ts

@@ -0,0 +1,5 @@
+export { runWranglerBundle } from './bundle.js';
+export { runWranglerDeploy, WranglerDeployError, type DeployArgs } from './deploy.js';
+export { wranglerProcessEnv } from './process.js';
+export { admitWranglerDeploymentStatus, runWranglerDeploymentStatus, type WranglerDeploymentStatus, } from './status.js';
+export { runWranglerTypes } from './type-generation.js';

package/dist/wrangler/index.js

@@ -0,0 +1,5 @@
+export { runWranglerBundle } from './bundle.js';
+export { runWranglerDeploy, WranglerDeployError } from './deploy.js';
+export { wranglerProcessEnv } from './process.js';
+export { admitWranglerDeploymentStatus, runWranglerDeploymentStatus, } from './status.js';
+export { runWranglerTypes } from './type-generation.js';

package/dist/wrangler/process.d.ts

@@ -0,0 +1,17 @@
+import type { ChildProcess } from 'node:child_process';
+export declare function wranglerCommand(projectDir: string, runtime?: {
+    readonly executable: string;
+    readonly bun: boolean;
+}): {
+    cmd: string;
+    prefix: string[];
+};
+/** Keep Wrangler CLI diagnostic logs inside the generated project state. */
+export declare function wranglerProcessEnv(projectDir: string): NodeJS.ProcessEnv;
+export declare function runCapture(cmd: string, args: string[], cwd: string, onLog?: (line: string) => void, signal?: AbortSignal, redact?: (input: string) => string): Promise<{
+    code: number;
+    out: string;
+    stdout: string;
+    stderr: string;
+}>;
+export declare function stopChild(child: ChildProcess): Promise<void>;

package/dist/wrangler/process.js

@@ -0,0 +1,115 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, resolve } from 'node:path';
+export function wranglerCommand(projectDir, runtime = {
+    executable: process.execPath,
+    bun: process.versions.bun !== undefined,
+}) {
+    const local = join(projectDir, 'node_modules', '.bin', 'wrangler');
+    if (existsSync(local))
+        return { cmd: local, prefix: [] };
+    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: runtime.bun ? 'node' : runtime.executable,
+        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'),
+    };
+}
+export function runCapture(cmd, args, cwd, onLog, signal, redact = (input) => input) {
+    if (signal?.aborted)
+        return Promise.reject(new Error('Wrangler process cancelled.'));
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: wranglerProcessEnv(cwd),
+        });
+        let out = '';
+        let stdout = '';
+        let stderr = '';
+        let outputBytes = 0;
+        let terminating;
+        const timeout = setTimeout(() => terminate(new Error('Wrangler process timed out.')), 300_000);
+        const abort = () => terminate(new Error('Wrangler process cancelled.'));
+        signal?.addEventListener('abort', abort, { once: true });
+        let escalation;
+        const cleanup = () => {
+            clearTimeout(timeout);
+            if (escalation !== undefined)
+                clearTimeout(escalation);
+            signal?.removeEventListener('abort', abort);
+        };
+        function terminate(cause) {
+            if (terminating !== undefined)
+                return;
+            terminating = cause;
+            child.kill('SIGTERM');
+            escalation = setTimeout(() => {
+                if (child.exitCode === null && child.signalCode === null)
+                    child.kill('SIGKILL');
+            }, 1_000);
+        }
+        const onData = (buffer, stream) => {
+            outputBytes += buffer.byteLength;
+            if (outputBytes > 1024 * 1024) {
+                terminate(new Error('Wrangler process exceeded its output limit.'));
+                return;
+            }
+            const chunk = buffer.toString();
+            out += chunk;
+            if (stream === 'stdout')
+                stdout += chunk;
+            else
+                stderr += chunk;
+        };
+        child.stdout?.on('data', (buffer) => onData(buffer, 'stdout'));
+        child.stderr?.on('data', (buffer) => onData(buffer, 'stderr'));
+        child.on('exit', (code) => {
+            cleanup();
+            if (terminating !== undefined)
+                reject(terminating);
+            else {
+                const safe = redact(out);
+                for (const line of safe.split('\n'))
+                    if (line.trim())
+                        onLog?.(line);
+                resolve({
+                    code: code ?? 1,
+                    out: safe,
+                    stdout: redact(stdout),
+                    stderr: redact(stderr),
+                });
+            }
+        });
+        child.on('error', (cause) => {
+            cleanup();
+            reject(terminating ?? cause);
+        });
+    });
+}
+export 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?.();
+    });
+}

package/dist/wrangler/secrets.d.ts

@@ -0,0 +1,6 @@
+export declare function withSecretsFile<Result>(secrets: Readonly<Record<string, string>>, operation: (path?: string) => Promise<Result>): Promise<Result>;
+export declare function createSecretEnvironment(secrets: Readonly<Record<string, string>>): Promise<{
+    readonly path: string;
+    remove(): Promise<void>;
+} | undefined>;
+export declare function secretRedactor(secrets: Readonly<Record<string, string>>): (input: string) => string;

package/dist/wrangler/secrets.js

@@ -0,0 +1,58 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+export 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(directory, { recursive: true, force: true });
+    }
+}
+export 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 }),
+    });
+}
+export function secretRedactor(secrets) {
+    const values = Object.values(secrets)
+        .filter((value) => value.length > 0)
+        .flatMap((value) => [value, JSON.stringify(value).slice(1, -1)])
+        .filter((value, index, all) => all.indexOf(value) === index)
+        .sort((left, right) => right.length - left.length);
+    return (input) => values.reduce((output, value) => output.replaceAll(value, '[REDACTED]'), input);
+}
+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.');
+}

package/dist/wrangler/status.d.ts

@@ -0,0 +1,14 @@
+export interface WranglerDeploymentStatus {
+    readonly deployment: string;
+    readonly versions: readonly {
+        readonly version: string;
+        readonly percentage: number;
+    }[];
+}
+export declare function runWranglerDeploymentStatus(args: {
+    readonly projectDir: string;
+    readonly configPath: string;
+    readonly workerName: string;
+    readonly signal?: AbortSignal;
+}): Promise<WranglerDeploymentStatus>;
+export declare function admitWranglerDeploymentStatus(output: string): WranglerDeploymentStatus;

package/dist/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/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/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;
+}