wrangler 0.0.0-e98613f8 → 0.0.0-e9a45766c

package/src/constellation/listModel.tsx

@@ -0,0 +1,41 @@
+import { withConfig } from "../config";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { takeName } from "./options";
+import {
+	constellationBetaWarning,
+	getProjectByName,
+	listModels,
+} from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+import type { Project } from "./types";
+
+export function options(yargs: CommonYargsArgv) {
+	return takeName(yargs)
+		.option("json", {
+			describe: "return output as clean JSON",
+			type: "boolean",
+			default: false,
+		})
+		.epilogue(constellationBetaWarning);
+}
+
+type HandlerOptions = StrictYargsOptionsToInterface<typeof options>;
+export const handler = withConfig<HandlerOptions>(
+	async ({ name, json, config }): Promise<void> => {
+		const accountId = await requireAuth(config);
+		const proj: Project = await getProjectByName(config, accountId, name);
+
+		const models = await listModels(accountId, proj);
+
+		if (json) {
+			logger.log(JSON.stringify(models, null, 2));
+		} else {
+			logger.log(constellationBetaWarning);
+			logger.table(models);
+		}
+	}
+);

package/src/constellation/listProject.tsx

@@ -0,0 +1,28 @@
+import { withConfig } from "../config";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { asJson } from "./options";
+import { constellationBetaWarning, listProjects } 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 projs = await listProjects(accountId);
+
+		if (json) {
+			logger.log(JSON.stringify(projs, null, 2));
+		} else {
+			logger.log(constellationBetaWarning);
+			logger.table(projs);
+		}
+	}
+);

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-preview.ts

@@ -109,6 +109,14 @@ function randomId(): string {
 	});
 }
 
+// URLs are often relative to the zone. Sometimes the base zone
+// will be grey-clouded, and so the host must be swapped out for
+// the worker route host, which is more likely to be orange-clouded
+function switchHost(originalUrl: string, host?: string): URL {
+	const url = new URL(originalUrl);
+	url.hostname = host ?? url.hostname;
+	return url;
+}
 /**
  * Generates a preview session token.
  */
@@ -129,9 +137,13 @@ export async function createPreviewSession(
 		abortSignal
 	);
 
-	logger.debug(`-- START EXCHANGE API REQUEST: GET ${exchange_url}`);
+	const switchedExchangeUrl = switchHost(exchange_url, ctx.host).toString();
+
+	logger.debug(`-- START EXCHANGE API REQUEST: GET ${switchedExchangeUrl}`);
 	logger.debug("-- END EXCHANGE API REQUEST");
-	const exchangeResponse = await fetch(exchange_url, { signal: abortSignal });
+	const exchangeResponse = await fetch(switchedExchangeUrl, {
+		signal: abortSignal,
+	});
 	const bodyText = await exchangeResponse.text();
 	logger.debug(
 		"-- START EXCHANGE API RESPONSE:",
@@ -147,16 +159,15 @@ export async function createPreviewSession(
 		token: string;
 		prewarm: string;
 	}>(bodyText);
-
-	const { host } = new URL(inspector_websocket);
-	const query = `cf_workers_preview_token=${token}`;
+	const inspector = new URL(inspector_websocket);
+	inspector.searchParams.append("cf_workers_preview_token", token);
 
 	return {
 		id: randomId(),
 		value: token,
-		host,
-		inspectorUrl: new URL(`${inspector_websocket}?${query}`),
-		prewarmUrl: new URL(prewarm),
+		host: ctx.host ?? inspector.host,
+		inspectorUrl: switchHost(inspector.href, ctx.host),
+		prewarmUrl: switchHost(prewarm, ctx.host),
 	};
 }
 

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 {
@@ -23,7 +24,7 @@ export function toMimeType(type: CfModuleType): string {
 	}
 }
 
-type WorkerMetadataBinding =
+export type WorkerMetadataBinding =
 	// If you add any new binding types here, also add it to safeBindings
 	// under validateUnsafeBinding in config/validation.ts
 	| { type: "plain_text"; name: string; text: string }
@@ -32,6 +33,12 @@ type WorkerMetadataBinding =
 	| { type: "text_blob"; name: string; part: string }
 	| { type: "data_blob"; name: string; part: string }
 	| { type: "kv_namespace"; name: string; namespace_id: string }
+	| {
+			type: "send_email";
+			name: string;
+			destination_address?: string;
+			allowed_destination_addresses?: string[];
+	  }
 	| {
 			type: "durable_object_namespace";
 			name: string;
@@ -43,7 +50,9 @@ type WorkerMetadataBinding =
 	| { type: "r2_bucket"; name: string; bucket_name: string }
 	| { type: "d1"; name: string; id: string; internalEnv?: string }
 	| { type: "service"; name: string; service: string; environment?: string }
-	| { type: "namespace"; name: string; namespace: string }
+	| { type: "analytics_engine"; name: string; dataset?: string }
+	| { type: "dispatch_namespace"; name: string; namespace: string }
+	| { type: "mtls_certificate"; name: string; certificate_id: string }
 	| {
 			type: "logfwdr";
 			name: string;
@@ -63,6 +72,9 @@ 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;
 }
 
 /**
@@ -79,6 +91,7 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		compatibility_flags,
 		keepVars,
 		logpush,
+		placement,
 	} = worker;
 
 	let { modules } = worker;
@@ -101,6 +114,17 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		});
 	});
 
+	bindings.send_email?.forEach(
+		({ name, destination_address, allowed_destination_addresses }) => {
+			metadataBindings.push({
+				name: name,
+				type: "send_email",
+				destination_address,
+				allowed_destination_addresses,
+			});
+		}
+	);
+
 	bindings.durable_objects?.bindings.forEach(
 		({ name, class_name, script_name, environment }) => {
 			metadataBindings.push({
@@ -149,14 +173,30 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		});
 	});
 
+	bindings.analytics_engine_datasets?.forEach(({ binding, dataset }) => {
+		metadataBindings.push({
+			name: binding,
+			type: "analytics_engine",
+			dataset,
+		});
+	});
+
 	bindings.dispatch_namespaces?.forEach(({ binding, namespace }) => {
 		metadataBindings.push({
 			name: binding,
-			type: "namespace",
+			type: "dispatch_namespace",
 			namespace,
 		});
 	});
 
+	bindings.mtls_certificates?.forEach(({ binding, certificate_id }) => {
+		metadataBindings.push({
+			name: binding,
+			type: "mtls_certificate",
+			certificate_id,
+		});
+	});
+
 	bindings.logfwdr?.bindings.forEach(({ name, destination }) => {
 		metadataBindings.push({
 			name: name,
@@ -266,9 +306,9 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		}
 	}
 
-	if (bindings.unsafe) {
+	if (bindings.unsafe?.bindings) {
 		// @ts-expect-error unsafe bindings don't need to match a specific type here
-		metadataBindings.push(...bindings.unsafe);
+		metadataBindings.push(...bindings.unsafe.bindings);
 	}
 
 	const metadata: WorkerMetadata = {
@@ -283,8 +323,15 @@ 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) {
+		for (const key of Object.keys(bindings.unsafe.metadata)) {
+			metadata[key] = bindings.unsafe.metadata[key];
+		}
+	}
+
 	formData.set("metadata", JSON.stringify(metadata));
 
 	if (main.type === "commonjs" && modules && modules.length > 0) {

package/src/d1/backups.tsx

@@ -1,6 +1,5 @@
 import fs from "node:fs/promises";
 import * as path from "path";
-import { render } from "ink";
 import Table from "ink-table";
 import React from "react";
 import { fetchResult } from "../cfetch";
@@ -8,22 +7,24 @@ import { performApiFetch } from "../cfetch/internal";
 import { withConfig } from "../config";
 import { logger } from "../logger";
 import { requireAuth } from "../user";
+import { renderToString } from "../utils/render";
 import { formatBytes, formatTimeAgo } from "./formatTimeAgo";
 import { Name } from "./options";
 import { d1BetaWarning, getDatabaseByNameOrBinding } from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
 import type { Backup, Database } from "./types";
 import type { Response } from "undici";
-import type { Argv } from "yargs";
 
-type BackupListArgs = { config?: string; name: string };
-
-export function ListOptions(yargs: Argv): Argv<BackupListArgs> {
+export function ListOptions(yargs: CommonYargsArgv) {
 	return Name(yargs);
 }
-
-export const ListHandler = withConfig<BackupListArgs>(
+type ListHandlerOptions = StrictYargsOptionsToInterface<typeof ListOptions>;
+export const ListHandler = withConfig<ListHandlerOptions>(
 	async ({ config, name }): Promise<void> => {
-		const accountId = await requireAuth({});
+		const accountId = await requireAuth(config);
 		logger.log(d1BetaWarning);
 		const db: Database = await getDatabaseByNameOrBinding(
 			config,
@@ -32,11 +33,13 @@ export const ListHandler = withConfig<BackupListArgs>(
 		);
 
 		const backups: Backup[] = await listBackups(accountId, db.uuid);
-		render(
-			<Table
-				data={backups}
-				columns={["created_at", "id", "num_tables", "size"]}
-			></Table>
+		logger.log(
+			renderToString(
+				<Table
+					data={backups}
+					columns={["created_at", "id", "num_tables", "size"]}
+				></Table>
+			)
 		);
 	}
 );
@@ -77,15 +80,14 @@ export const listBackups = async (
 	return Object.values(results);
 };
 
-type BackupCreateArgs = BackupListArgs;
-
-export function CreateOptions(yargs: Argv): Argv<BackupCreateArgs> {
+export function CreateOptions(yargs: CommonYargsArgv) {
 	return ListOptions(yargs);
 }
+type CreateHandlerOptions = StrictYargsOptionsToInterface<typeof CreateOptions>;
 
-export const CreateHandler = withConfig<BackupCreateArgs>(
+export const CreateHandler = withConfig<CreateHandlerOptions>(
 	async ({ config, name }): Promise<void> => {
-		const accountId = await requireAuth({});
+		const accountId = await requireAuth(config);
 		logger.log(d1BetaWarning);
 		const db: Database = await getDatabaseByNameOrBinding(
 			config,
@@ -94,11 +96,13 @@ export const CreateHandler = withConfig<BackupCreateArgs>(
 		);
 
 		const backup: Backup = await createBackup(accountId, db.uuid);
-		render(
-			<Table
-				data={[backup]}
-				columns={["created_at", "id", "num_tables", "size", "state"]}
-			></Table>
+		logger.log(
+			renderToString(
+				<Table
+					data={[backup]}
+					columns={["created_at", "id", "num_tables", "size", "state"]}
+				></Table>
+			)
 		);
 	}
 );
@@ -119,21 +123,19 @@ export const createBackup = async (
 	};
 };
 
-type BackupRestoreArgs = BackupListArgs & {
-	"backup-id": string;
-};
-
-export function RestoreOptions(yargs: Argv): Argv<BackupRestoreArgs> {
+export function RestoreOptions(yargs: CommonYargsArgv) {
 	return ListOptions(yargs).positional("backup-id", {
 		describe: "The Backup ID to restore",
 		type: "string",
 		demandOption: true,
 	});
 }
-
-export const RestoreHandler = withConfig<BackupRestoreArgs>(
+type RestoreHandlerOptions = StrictYargsOptionsToInterface<
+	typeof RestoreOptions
+>;
+export const RestoreHandler = withConfig<RestoreHandlerOptions>(
 	async ({ config, name, backupId }): Promise<void> => {
-		const accountId = await requireAuth({});
+		const accountId = await requireAuth(config);
 		logger.log(d1BetaWarning);
 		const db: Database = await getDatabaseByNameOrBinding(
 			config,
@@ -163,11 +165,7 @@ export const restoreBackup = async (
 	);
 };
 
-type BackupDownloadArgs = BackupRestoreArgs & {
-	output?: string;
-};
-
-export function DownloadOptions(yargs: Argv): Argv<BackupDownloadArgs> {
+export function DownloadOptions(yargs: CommonYargsArgv) {
 	return ListOptions(yargs)
 		.positional("backup-id", {
 			describe: "The Backup ID to download",
@@ -180,10 +178,12 @@ export function DownloadOptions(yargs: Argv): Argv<BackupDownloadArgs> {
 			type: "string",
 		});
 }
-
-export const DownloadHandler = withConfig<BackupDownloadArgs>(
+type DownloadHandlerOptions = StrictYargsOptionsToInterface<
+	typeof DownloadOptions
+>;
+export const DownloadHandler = withConfig<DownloadHandlerOptions>(
 	async ({ name, backupId, output, config }): Promise<void> => {
-		const accountId = await requireAuth({});
+		const accountId = await requireAuth(config);
 		logger.log(d1BetaWarning);
 		const db: Database = await getDatabaseByNameOrBinding(
 			config,
@@ -191,11 +191,7 @@ export const DownloadHandler = withConfig<BackupDownloadArgs>(
 			name
 		);
 		const filename =
-			output ||
-			path.join(
-				process.env.INIT_CWD as string,
-				`${name}.${backupId.slice(0, 8)}.sqlite3`
-			);
+			output || path.resolve(`${name}.${backupId.slice(0, 8)}.sqlite3`);
 
 		logger.log(`🌀 Downloading backup ${backupId} from '${name}'`);
 		const response = await getBackupResponse(accountId, db.uuid, backupId);