wrangler 2.18.0 → 2.20.0

package/src/constellation/listRuntime.tsx

@@ -0,0 +1,28 @@
+import { withConfig } from "../config";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { asJson } from "./options";
+import { constellationBetaWarning, listRuntimes } from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+
+export function options(yargs: CommonYargsArgv) {
+	return asJson(yargs).epilogue(constellationBetaWarning);
+}
+
+type HandlerOptions = StrictYargsOptionsToInterface<typeof options>;
+export const handler = withConfig<HandlerOptions>(
+	async ({ json, config }): Promise<void> => {
+		const accountId = await requireAuth(config);
+		const runtimes = await listRuntimes(accountId);
+
+		if (json) {
+			logger.log(JSON.stringify(runtimes, null, 2));
+		} else {
+			logger.log(constellationBetaWarning);
+			logger.table(runtimes.map((runtime) => ({ name: runtime })));
+		}
+	}
+);

package/src/constellation/options.ts

@@ -0,0 +1,17 @@
+import type { CommonYargsArgv } from "../yargs-types";
+
+export function takeName(yargs: CommonYargsArgv) {
+	return yargs.positional("name", {
+		describe: "The name of the project",
+		type: "string",
+		demandOption: true,
+	});
+}
+
+export function asJson(yargs: CommonYargsArgv) {
+	return yargs.option("json", {
+		describe: "return output as clean JSON",
+		type: "boolean",
+		default: false,
+	});
+}

package/src/constellation/types.ts

@@ -0,0 +1,17 @@
+export type Project = {
+	id: string;
+	name: string;
+	runtime: string;
+};
+
+export type Model = {
+	id: string;
+	project_id: string;
+	name: string;
+	description: string;
+};
+
+export type CatalogEntry = {
+	project: Project;
+	models: Model[];
+};

package/src/constellation/uploadModel.tsx

@@ -0,0 +1,64 @@
+import { readFileSync } from "node:fs";
+import { FormData, File } from "undici";
+import { fetchResult } from "../cfetch";
+import { withConfig } from "../config";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { takeName } from "./options";
+import { constellationBetaWarning, getProjectByName } from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+import type { Model } from "./types";
+
+export function options(yargs: CommonYargsArgv) {
+	return takeName(yargs)
+		.positional("modelName", {
+			describe: "The name of the uploaded model",
+			type: "string",
+			demandOption: true,
+		})
+		.positional("modelFile", {
+			describe: "The name of the local file with the model contents",
+			type: "string",
+			demandOption: true,
+		})
+		.epilogue(constellationBetaWarning);
+}
+type HandlerOptions = StrictYargsOptionsToInterface<typeof options>;
+export const handler = withConfig<HandlerOptions>(
+	async ({ name, modelName, modelFile, config }): Promise<void> => {
+		const accountId = await requireAuth(config);
+		logger.log(constellationBetaWarning);
+
+		const proj = await getProjectByName(config, accountId, name);
+
+		const formData = new FormData();
+		formData.set(
+			"file",
+			new File([readFileSync(modelFile)], modelFile, {
+				type: "application/octet-stream",
+			})
+		);
+		formData.set("name", modelName);
+
+		let model: Model;
+		try {
+			model = await fetchResult(
+				`/accounts/${accountId}/constellation/project/${proj.id}/model`,
+				{
+					method: "POST",
+					body: formData,
+				}
+			);
+		} catch (e) {
+			if ((e as { code: number }).code === 7408) {
+				throw new Error("A model with that name already exists");
+			}
+			throw e;
+		}
+
+		logger.log(`✅ Successfully uploaded Model "${model.name}"!`);
+	}
+);

package/src/constellation/utils.ts

@@ -0,0 +1,90 @@
+import { fetchResult } from "../cfetch";
+import { getEnvironmentVariableFactory } from "../environment-variables/factory";
+import type { Config } from "../config";
+import type { Project, Model, CatalogEntry } from "./types";
+
+export const getConstellationWarningFromEnv = getEnvironmentVariableFactory({
+	variableName: "NO_CONSTELLATION_WARNING",
+});
+
+export const constellationBetaWarning =
+	getConstellationWarningFromEnv() !== undefined
+		? ""
+		: "--------------------\n🚧 Constellation AI is currently in open alpha and is not recommended for production data and traffic\n🚧 Please report any bugs to https://github.com/cloudflare/workers-sdk/issues/new/choose\n🚧 To give feedback, visit https://discord.gg/cloudflaredev\n--------------------\n";
+
+export const getProjectByName = async (
+	config: Config,
+	accountId: string,
+	name: string
+): Promise<Project> => {
+	const allProjects = await listProjects(accountId);
+	const matchingProj = allProjects.find((proj) => proj.name === name);
+	if (!matchingProj) {
+		throw new Error(`Couldn't find Project with name '${name}'`);
+	}
+	return matchingProj;
+};
+
+export const getProjectModelByName = async (
+	config: Config,
+	accountId: string,
+	proj: Project,
+	modelName: string
+): Promise<Model> => {
+	const allModels = await listModels(accountId, proj);
+	const matchingModel = allModels.find((model) => model.name === modelName);
+	if (!matchingModel) {
+		throw new Error(`Couldn't find Model with name '${modelName}'`);
+	}
+	return matchingModel;
+};
+
+export async function constellationList<ResponseType>(
+	accountId: string,
+	partialUrl: string
+): Promise<Array<ResponseType>> {
+	const pageSize = 50;
+	let page = 1;
+	const results = [];
+	while (results.length % pageSize === 0) {
+		const json: Array<ResponseType> = await fetchResult(
+			`/accounts/${accountId}/constellation/${partialUrl}`,
+			{},
+			new URLSearchParams({
+				per_page: pageSize.toString(),
+				page: page.toString(),
+			})
+		);
+		page++;
+		results.push(...json);
+		if (json.length < pageSize) {
+			break;
+		}
+	}
+	return results;
+}
+
+export const listCatalogEntries = async (
+	accountId: string
+): Promise<Array<CatalogEntry>> => {
+	return await constellationList(accountId, "catalog");
+};
+
+export const listModels = async (
+	accountId: string,
+	proj: Project
+): Promise<Array<Model>> => {
+	return constellationList(accountId, `project/${proj.id}/model`);
+};
+
+export const listProjects = async (
+	accountId: string
+): Promise<Array<Project>> => {
+	return await constellationList(accountId, "project");
+};
+
+export const listRuntimes = async (
+	accountId: string
+): Promise<Array<string>> => {
+	return await constellationList(accountId, "runtime");
+};

package/src/create-worker-upload-form.ts

@@ -4,6 +4,7 @@ import type {
 	CfWorkerInit,
 	CfModuleType,
 	CfDurableObjectMigrations,
+	CfPlacement,
 } from "./worker.js";
 
 export function toMimeType(type: CfModuleType): string {
@@ -71,6 +72,7 @@ export interface WorkerMetadata {
 	bindings: WorkerMetadataBinding[];
 	keep_bindings?: WorkerMetadataBinding["type"][];
 	logpush?: boolean;
+	placement?: CfPlacement;
 	// Allow unsafe.metadata to add arbitary properties at runtime
 	[key: string]: unknown;
 }
@@ -89,6 +91,7 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		compatibility_flags,
 		keepVars,
 		logpush,
+		placement,
 	} = worker;
 
 	let { modules } = worker;
@@ -320,6 +323,7 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		capnp_schema: bindings.logfwdr?.schema,
 		...(keepVars && { keep_bindings: ["plain_text", "json"] }),
 		...(logpush !== undefined && { logpush }),
+		...(placement && { placement }),
 	};
 
 	if (bindings.unsafe?.metadata !== undefined) {

package/src/dev/dev.tsx

@@ -116,6 +116,7 @@ export type DevProps = {
 	initialPort: number;
 	initialIp: string;
 	inspectorPort: number;
+	processEntrypoint: boolean;
 	rules: Config["rules"];
 	accountId: string | undefined;
 	initialMode: "local" | "remote";
@@ -187,6 +188,7 @@ function InteractiveDevSession(props: DevProps) {
 		inspect: props.inspect,
 		localProtocol: props.localProtocol,
 		forceLocal: props.forceLocal,
+		worker: props.name,
 	});
 
 	ip = props.initialIp;
@@ -271,6 +273,7 @@ function DevSession(props: DevSessionProps) {
 		entry: props.entry,
 		destination: directory,
 		jsxFactory: props.jsxFactory,
+		processEntrypoint: props.processEntrypoint,
 		rules: props.rules,
 		jsxFragment: props.jsxFragment,
 		serveAssetsFromWorker: Boolean(
@@ -348,6 +351,7 @@ function DevSession(props: DevSessionProps) {
 			experimentalLocal={props.experimentalLocal}
 			accountId={props.accountId}
 			experimentalLocalRemoteKv={props.experimentalLocalRemoteKv}
+			sourceMapPath={bundle?.sourceMapPath}
 		/>
 	) : (
 		<Remote
@@ -526,6 +530,7 @@ function useHotkeys(props: {
 	inspect: boolean;
 	localProtocol: "http" | "https";
 	forceLocal: boolean | undefined;
+	worker: string | undefined;
 }) {
 	const { initial, inspectorPort, inspect, localProtocol, forceLocal } = props;
 	// UGH, we should put port in context instead
@@ -558,7 +563,7 @@ function useHotkeys(props: {
 				// toggle inspector
 				case "d": {
 					if (inspect) {
-						await openInspector(inspectorPort);
+						await openInspector(inspectorPort, props.worker);
 					}
 					break;
 				}

package/src/dev/local.tsx

@@ -75,6 +75,7 @@ export interface LocalProps {
 	experimentalLocal: boolean | undefined;
 	accountId: string | undefined; // Account ID? In local mode??? :exploding_head:
 	experimentalLocalRemoteKv: boolean | undefined;
+	sourceMapPath: string | undefined;
 }
 
 type InspectorJSON = {
@@ -95,6 +96,9 @@ export function Local(props: LocalProps) {
 		inspectorUrl,
 		port: props.inspectorPort,
 		logToTerminal: props.experimentalLocal ?? false,
+		sourceMapPath: props.sourceMapPath,
+		name: props.name,
+		sourceMapMetadata: props.bundle?.sourceMapMetadata,
 	});
 	return null;
 }

package/src/dev/remote.tsx

@@ -107,6 +107,8 @@ export function Remote(props: RemoteProps) {
 		logToTerminal: true,
 		sourceMapPath: props.sourceMapPath,
 		host: previewToken?.host,
+		name: props.name,
+		sourceMapMetadata: props.bundle?.sourceMapMetadata,
 	});
 
 	const errorHandler = useErrorHandler();
@@ -574,6 +576,7 @@ async function createRemoteWorkerInit(props: {
 		usage_model: props.usageModel,
 		keepVars: true,
 		logpush: false,
+		placement: undefined, // no placement in dev
 	};
 
 	return init;

package/src/dev/start-server.ts

@@ -92,6 +92,7 @@ export async function startDevServer(
 			entry: props.entry,
 			destination: directory.name,
 			jsxFactory: props.jsxFactory,
+			processEntrypoint: props.processEntrypoint,
 			rules: props.rules,
 			jsxFragment: props.jsxFragment,
 			serveAssetsFromWorker: Boolean(
@@ -141,6 +142,7 @@ export async function startDevServer(
 				experimentalLocal: props.experimentalLocal,
 				accountId: props.accountId,
 				experimentalLocalRemoteKv: props.experimentalLocalRemoteKv,
+				sourceMapPath: bundle?.sourceMapPath,
 			});
 
 			return {
@@ -205,6 +207,7 @@ async function runEsbuild({
 	destination,
 	jsxFactory,
 	jsxFragment,
+	processEntrypoint,
 	rules,
 	assets,
 	betaD1Shims,
@@ -227,6 +230,7 @@ async function runEsbuild({
 	destination: string | undefined;
 	jsxFactory: string | undefined;
 	jsxFragment: string | undefined;
+	processEntrypoint: boolean;
 	rules: Config["rules"];
 	assets: Config["assets"];
 	betaD1Shims?: string[];
@@ -247,49 +251,56 @@ async function runEsbuild({
 }): Promise<EsbuildBundle | undefined> {
 	if (!destination) return;
 
-	const {
-		resolvedEntryPointPath,
-		bundleType,
-		modules,
-		dependencies,
-		sourceMapPath,
-	}: Awaited<ReturnType<typeof bundleWorker>> = noBundle
-		? await traverseModuleGraph(entry, rules)
-		: await bundleWorker(entry, destination, {
-				serveAssetsFromWorker,
-				jsxFactory,
-				jsxFragment,
-				rules,
-				tsconfig,
-				minify,
-				legacyNodeCompat,
-				nodejsCompat,
-				define,
-				checkFetch: true,
-				assets: assets && {
-					...assets,
-					// disable the cache in dev
-					bypassCache: true,
-				},
-				betaD1Shims,
-				workerDefinitions,
-				services,
-				firstPartyWorkerDevFacade,
-				targetConsumer: "dev", // We are starting a dev server
-				testScheduled,
-				local,
-				experimentalLocal,
-				doBindings,
-		  });
+	let traverseModuleGraphResult:
+		| Awaited<ReturnType<typeof bundleWorker>>
+		| undefined;
+	let bundleResult: Awaited<ReturnType<typeof bundleWorker>> | undefined;
+	if (noBundle) {
+		traverseModuleGraphResult = await traverseModuleGraph(entry, rules);
+	}
+
+	if (processEntrypoint || !noBundle) {
+		bundleResult = await bundleWorker(entry, destination, {
+			bundle: !noBundle,
+			disableModuleCollection: noBundle,
+			serveAssetsFromWorker,
+			jsxFactory,
+			jsxFragment,
+			rules,
+			tsconfig,
+			minify,
+			legacyNodeCompat,
+			nodejsCompat,
+			define,
+			checkFetch: true,
+			assets: assets && {
+				...assets,
+				// disable the cache in dev
+				bypassCache: true,
+			},
+			betaD1Shims,
+			workerDefinitions,
+			services,
+			firstPartyWorkerDevFacade,
+			targetConsumer: "dev", // We are starting a dev server
+			testScheduled,
+			local,
+			experimentalLocal,
+			doBindings,
+		});
+	}
 
 	return {
 		id: 0,
 		entry,
-		path: resolvedEntryPointPath,
-		type: bundleType,
-		modules,
-		dependencies,
-		sourceMapPath,
+		path: bundleResult?.resolvedEntryPointPath ?? entry.file,
+		type:
+			bundleResult?.bundleType ??
+			(entry.format === "modules" ? "esm" : "commonjs"),
+		modules: traverseModuleGraphResult?.modules ?? bundleResult?.modules ?? [],
+		dependencies: bundleResult?.dependencies ?? {},
+		sourceMapPath: bundleResult?.sourceMapPath,
+		sourceMapMetadata: bundleResult?.sourceMapMetadata,
 	};
 }
 

package/src/dev/use-esbuild.ts

@@ -8,6 +8,7 @@ import traverseModuleGraph from "../traverse-module-graph";
 import type { Config } from "../config";
 import type { WorkerRegistry } from "../dev-registry";
 import type { Entry } from "../entry";
+import type { SourceMapMetadata } from "../inspect";
 import type { CfModule } from "../worker";
 import type { WatchMode, Metafile } from "esbuild";
 
@@ -19,6 +20,7 @@ export type EsbuildBundle = {
 	modules: CfModule[];
 	dependencies: Metafile["outputs"][string]["inputs"];
 	sourceMapPath: string | undefined;
+	sourceMapMetadata: SourceMapMetadata | undefined;
 };
 
 export function useEsbuild({
@@ -26,6 +28,7 @@ export function useEsbuild({
 	destination,
 	jsxFactory,
 	jsxFragment,
+	processEntrypoint,
 	rules,
 	assets,
 	serveAssetsFromWorker,
@@ -49,6 +52,7 @@ export function useEsbuild({
 	destination: string | undefined;
 	jsxFactory: string | undefined;
 	jsxFragment: string | undefined;
+	processEntrypoint: boolean;
 	rules: Config["rules"];
 	assets: Config["assets"];
 	define: Config["define"];
@@ -100,45 +104,48 @@ export function useEsbuild({
 		async function build() {
 			if (!destination) return;
 
-			const {
-				resolvedEntryPointPath,
-				bundleType,
-				modules,
-				dependencies,
-				stop,
-				sourceMapPath,
-			}: Awaited<ReturnType<typeof bundleWorker>> = noBundle
-				? await traverseModuleGraph(entry, rules)
-				: await bundleWorker(entry, destination, {
-						serveAssetsFromWorker,
-						jsxFactory,
-						jsxFragment,
-						rules,
-						watch: watchMode,
-						tsconfig,
-						minify,
-						legacyNodeCompat,
-						nodejsCompat,
-						betaD1Shims,
-						doBindings: durableObjects.bindings,
-						define,
-						checkFetch: true,
-						assets: assets && {
-							...assets,
-							// disable the cache in dev
-							bypassCache: true,
-						},
-						workerDefinitions,
-						services,
-						firstPartyWorkerDevFacade,
-						local,
-						targetConsumer,
-						testScheduled,
-						experimentalLocal,
-				  });
+			let traverseModuleGraphResult:
+				| Awaited<ReturnType<typeof bundleWorker>>
+				| undefined;
+			let bundleResult: Awaited<ReturnType<typeof bundleWorker>> | undefined;
+			if (noBundle) {
+				traverseModuleGraphResult = await traverseModuleGraph(entry, rules);
+			}
+
+			if (processEntrypoint || !noBundle) {
+				bundleResult = await bundleWorker(entry, destination, {
+					bundle: !noBundle,
+					disableModuleCollection: noBundle,
+					serveAssetsFromWorker,
+					jsxFactory,
+					jsxFragment,
+					rules,
+					watch: watchMode,
+					tsconfig,
+					minify,
+					legacyNodeCompat,
+					nodejsCompat,
+					betaD1Shims,
+					doBindings: durableObjects.bindings,
+					define,
+					checkFetch: true,
+					assets: assets && {
+						...assets,
+						// disable the cache in dev
+						bypassCache: true,
+					},
+					workerDefinitions,
+					services,
+					firstPartyWorkerDevFacade,
+					local,
+					targetConsumer,
+					testScheduled,
+					experimentalLocal,
+				});
+			}
 
 			// Capture the `stop()` method to use as the `useEffect()` destructor.
-			stopWatching = stop;
+			stopWatching = bundleResult?.stop;
 
 			// if "noBundle" is true, then we need to manually watch the entry point and
 			// trigger "builds" when it changes
@@ -156,11 +163,15 @@ export function useEsbuild({
 			setBundle({
 				id: 0,
 				entry,
-				path: resolvedEntryPointPath,
-				type: bundleType,
-				modules,
-				dependencies,
-				sourceMapPath,
+				path: bundleResult?.resolvedEntryPointPath ?? entry.file,
+				type:
+					bundleResult?.bundleType ??
+					(entry.format === "modules" ? "esm" : "commonjs"),
+				modules:
+					traverseModuleGraphResult?.modules ?? bundleResult?.modules ?? [],
+				dependencies: bundleResult?.dependencies ?? {},
+				sourceMapPath: bundleResult?.sourceMapPath,
+				sourceMapMetadata: bundleResult?.sourceMapMetadata,
 			});
 		}
 
@@ -180,6 +191,7 @@ export function useEsbuild({
 		jsxFactory,
 		jsxFragment,
 		serveAssetsFromWorker,
+		processEntrypoint,
 		rules,
 		tsconfig,
 		exit,

package/src/dev.tsx

@@ -28,7 +28,7 @@ import {
 	printWranglerBanner,
 } from "./index";
 import type { Config, Environment } from "./config";
-import type { Route } from "./config/environment";
+import type { Route, Rule } from "./config/environment";
 import type { LoggerLevel } from "./logger";
 import type { EnablePagesAssetsServiceBindingOptions } from "./miniflare-cli/types";
 import type { CfWorkerInit } from "./worker";
@@ -334,6 +334,9 @@ export type AdditionalDevProps = {
 		preview_bucket_name?: string;
 	}[];
 	d1Databases?: Environment["d1_databases"];
+	processEntrypoint?: boolean;
+	moduleRoot?: string;
+	rules?: Rule[];
 };
 
 type StartDevOptions = DevArguments &
@@ -424,7 +427,8 @@ export async function startDev(args: StartDevOptions) {
 					zone={zoneId}
 					host={host}
 					routes={routes}
-					rules={getRules(configParam)}
+					processEntrypoint={!!args.processEntrypoint}
+					rules={args.rules ?? getRules(configParam)}
 					legacyEnv={isLegacyEnv(configParam)}
 					minify={args.minify ?? configParam.minify}
 					legacyNodeCompat={legacyNodeCompat}
@@ -560,7 +564,8 @@ export async function startApiDev(args: StartDevOptions) {
 			zone: zoneId,
 			host: host,
 			routes: routes,
-			rules: getRules(configParam),
+			processEntrypoint: !!args.processEntrypoint,
+			rules: args.rules ?? getRules(configParam),
 			legacyEnv: isLegacyEnv(configParam),
 			minify: args.minify ?? configParam.minify,
 			legacyNodeCompat,
@@ -687,7 +692,7 @@ async function validateDevServerSettings(
 	config: Config
 ) {
 	const entry = await getEntry(
-		{ assets: args.assets, script: args.script },
+		{ assets: args.assets, script: args.script, moduleRoot: args.moduleRoot },
 		config,
 		"dev"
 	);

package/src/entry.ts

@@ -25,6 +25,11 @@ export type Entry = {
 	format: CfScriptFormat;
 	/** The directory that contains all of a `--no-bundle` worker's modules. Usually `${directory}/src`. Defaults to path.dirname(file) */
 	moduleRoot: string;
+
+	/**
+	 * A worker's name
+	 */
+	name?: string | undefined;
 };
 
 /**
@@ -35,6 +40,7 @@ export async function getEntry(
 		script?: string;
 		format?: CfScriptFormat | undefined;
 		assets?: string | undefined;
+		moduleRoot?: string;
 	},
 	config: Config,
 	command: "dev" | "publish" | "types"
@@ -113,7 +119,8 @@ export async function getEntry(
 		file,
 		directory,
 		format,
-		moduleRoot: config.base_dir ?? path.dirname(file),
+		moduleRoot: args.moduleRoot ?? config.base_dir ?? path.dirname(file),
+		name: config.name ?? "worker",
 	};
 }