wrangler 0.0.0-e6733a3 → 0.0.0-e6c71262

package/src/tail/index.ts

@@ -0,0 +1,211 @@
+import { setTimeout } from "node:timers/promises";
+import onExit from "signal-exit";
+
+import { fetchResult, fetchScriptContent } from "../cfetch";
+import { readConfig } from "../config";
+import { confirm } from "../dialogs";
+import {
+	isLegacyEnv,
+	printWranglerBanner,
+	getLegacyScriptName,
+} from "../index";
+import { logger } from "../logger";
+import * as metrics from "../metrics";
+import { requireAuth } from "../user";
+import { getWorkerForZone } from "../zones";
+import {
+	createTail,
+	jsonPrintLogs,
+	prettyPrintLogs,
+	translateCLICommandToFilterMessage,
+} from "./createTail";
+import type { WorkerMetadata } from "../create-worker-upload-form";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+import type { TailCLIFilters } from "./createTail";
+import type { RawData } from "ws";
+
+export function tailOptions(yargs: CommonYargsArgv) {
+	return yargs
+		.positional("worker", {
+			describe: "Name or route of the worker to tail",
+			type: "string",
+		})
+		.option("format", {
+			default: process.stdout.isTTY ? "pretty" : "json",
+			choices: ["json", "pretty"],
+			describe: "The format of log entries",
+		})
+		.option("status", {
+			choices: ["ok", "error", "canceled"],
+			describe: "Filter by invocation status",
+			array: true,
+		})
+		.option("header", {
+			type: "string",
+			requiresArg: true,
+			describe: "Filter by HTTP header",
+		})
+		.option("method", {
+			type: "string",
+			requiresArg: true,
+			describe: "Filter by HTTP method",
+			array: true,
+		})
+		.option("sampling-rate", {
+			type: "number",
+			describe: "Adds a percentage of requests to log sampling rate",
+		})
+		.option("search", {
+			type: "string",
+			requiresArg: true,
+			describe: "Filter by a text match in console.log messages",
+		})
+		.option("ip", {
+			type: "string",
+			requiresArg: true,
+			describe:
+				'Filter by the IP address the request originates from. Use "self" to filter for your own IP',
+			array: true,
+		})
+		.option("debug", {
+			type: "boolean",
+			hidden: true,
+			default: false,
+			describe:
+				"If a log would have been filtered out, send it through anyway alongside the filter which would have blocked it.",
+		})
+		.option("legacy-env", {
+			type: "boolean",
+			describe: "Use legacy environments",
+			hidden: true,
+		});
+}
+
+type TailArgs = StrictYargsOptionsToInterface<typeof tailOptions>;
+
+export async function tailHandler(args: TailArgs) {
+	if (args.format === "pretty") {
+		await printWranglerBanner();
+	}
+	const config = readConfig(args.config, args);
+	await metrics.sendMetricsEvent("begin log stream", {
+		sendMetrics: config.send_metrics,
+	});
+
+	let scriptName;
+
+	// Worker names can't contain "." (and most routes should), so use that as a discriminator
+	if (args.worker?.includes(".")) {
+		scriptName = await getWorkerForZone(args.worker);
+		if (args.format === "pretty") {
+			logger.log(`Connecting to worker ${scriptName} at route ${args.worker}`);
+		}
+	} else {
+		scriptName = getLegacyScriptName({ name: args.worker, ...args }, config);
+	}
+
+	if (!scriptName) {
+		throw new Error(
+			"Required Worker name missing. Please specify the Worker name in wrangler.toml, or pass it as an argument with `wrangler tail <worker-name>`"
+		);
+	}
+
+	const accountId = await requireAuth(config);
+
+	const cliFilters: TailCLIFilters = {
+		status: args.status as ("ok" | "error" | "canceled")[] | undefined,
+		header: args.header,
+		method: args.method,
+		samplingRate: args.samplingRate,
+		search: args.search,
+		clientIp: args.ip,
+	};
+	const scriptContent: string = await fetchScriptContent(
+		(!isLegacyEnv(config) ? args.env : undefined)
+			? `/accounts/${accountId}/workers/services/${scriptName}/environments/${args.env}/content`
+			: `/accounts/${accountId}/workers/scripts/${scriptName}`
+	);
+
+	const bindings = await fetchResult<WorkerMetadata["bindings"]>(
+		(!isLegacyEnv(config) ? args.env : undefined)
+			? `/accounts/${accountId}/workers/services/${scriptName}/environments/${args.env}/bindings`
+			: `/accounts/${accountId}/workers/scripts/${scriptName}/bindings`
+	);
+	if (
+		scriptContent.toLowerCase().includes("websocket") &&
+		bindings.find((b) => b.type === "durable_object_namespace")
+	) {
+		logger.warn(
+			`Beginning log collection requires restarting the Durable Objects associated with ${scriptName}. Any WebSocket connections or other non-persisted state will be lost as part of this restart.`
+		);
+
+		if (!(await confirm("Would you like to continue?"))) {
+			return;
+		}
+	}
+	const filters = translateCLICommandToFilterMessage(cliFilters);
+
+	const { tail, expiration, deleteTail } = await createTail(
+		accountId,
+		scriptName,
+		filters,
+		args.debug,
+		!isLegacyEnv(config) ? args.env : undefined
+	);
+
+	const scriptDisplayName = `${scriptName}${
+		args.env && !isLegacyEnv(config) ? ` (${args.env})` : ""
+	}`;
+
+	if (args.format === "pretty") {
+		logger.log(
+			`Successfully created tail, expires at ${expiration.toLocaleString()}`
+		);
+	}
+
+	onExit(async () => {
+		tail.terminate();
+		await deleteTail();
+		await metrics.sendMetricsEvent("end log stream", {
+			sendMetrics: config.send_metrics,
+		});
+	});
+
+	const printLog: (data: RawData) => void =
+		args.format === "pretty" ? prettyPrintLogs : jsonPrintLogs;
+
+	tail.on("message", printLog);
+
+	while (tail.readyState !== tail.OPEN) {
+		switch (tail.readyState) {
+			case tail.CONNECTING:
+				await setTimeout(100);
+				break;
+			case tail.CLOSING:
+				await setTimeout(100);
+				break;
+			case tail.CLOSED:
+				await metrics.sendMetricsEvent("end log stream", {
+					sendMetrics: config.send_metrics,
+				});
+				throw new Error(
+					`Connection to ${scriptDisplayName} closed unexpectedly.`
+				);
+		}
+	}
+
+	if (args.format === "pretty") {
+		logger.log(`Connected to ${scriptDisplayName}, waiting for logs...`);
+	}
+
+	tail.on("close", async () => {
+		tail.terminate();
+		await deleteTail();
+		await metrics.sendMetricsEvent("end log stream", {
+			sendMetrics: config.send_metrics,
+		});
+	});
+}

package/src/tail/printing.ts

@@ -0,0 +1,132 @@
+import chalk from "chalk";
+import { logger } from "../logger";
+import type {
+	AlarmEvent,
+	EmailEvent,
+	RequestEvent,
+	ScheduledEvent,
+	TailInfo,
+	TailEventMessage,
+} from "./createTail";
+import type { Outcome } from "./filters";
+import type WebSocket from "ws";
+
+export function prettyPrintLogs(data: WebSocket.RawData): void {
+	const eventMessage: TailEventMessage = JSON.parse(data.toString());
+
+	if (isScheduledEvent(eventMessage.event)) {
+		const cronPattern = eventMessage.event.cron;
+		const datetime = new Date(
+			eventMessage.event.scheduledTime
+		).toLocaleString();
+		const outcome = prettifyOutcome(eventMessage.outcome);
+
+		logger.log(`"${cronPattern}" @ ${datetime} - ${outcome}`);
+	} else if (isRequestEvent(eventMessage.event)) {
+		const requestMethod = eventMessage.event?.request.method.toUpperCase();
+		const url = eventMessage.event?.request.url;
+		const outcome = prettifyOutcome(eventMessage.outcome);
+		const datetime = new Date(eventMessage.eventTimestamp).toLocaleString();
+
+		logger.log(
+			url
+				? `${requestMethod} ${url} - ${outcome} @ ${datetime}`
+				: `[missing request] - ${outcome} @ ${datetime}`
+		);
+	} else if (isEmailEvent(eventMessage.event)) {
+		const outcome = prettifyOutcome(eventMessage.outcome);
+		const datetime = new Date(eventMessage.eventTimestamp).toLocaleString();
+		const mailFrom = eventMessage.event.mailFrom;
+		const rcptTo = eventMessage.event.rcptTo;
+		const rawSize = eventMessage.event.rawSize;
+
+		logger.log(
+			`Email from:${mailFrom} to:${rcptTo} size:${rawSize} @ ${datetime} - ${outcome}`
+		);
+	} else if (isAlarmEvent(eventMessage.event)) {
+		const outcome = prettifyOutcome(eventMessage.outcome);
+		const datetime = new Date(
+			eventMessage.event.scheduledTime
+		).toLocaleString();
+
+		logger.log(`Alarm @ ${datetime} - ${outcome}`);
+	} else if (isTailInfo(eventMessage.event)) {
+		if (eventMessage.event.type === "overload") {
+			logger.log(`${chalk.red.bold(eventMessage.event.message)}`);
+		}
+	} else {
+		// Unknown event type
+		const outcome = prettifyOutcome(eventMessage.outcome);
+		const datetime = new Date(eventMessage.eventTimestamp).toLocaleString();
+
+		logger.log(`Unknown Event - ${outcome} @ ${datetime}`);
+	}
+
+	if (eventMessage.logs.length > 0) {
+		eventMessage.logs.forEach(({ level, message }) => {
+			logger.log(`  (${level})`, ...message);
+		});
+	}
+
+	if (eventMessage.exceptions.length > 0) {
+		eventMessage.exceptions.forEach(({ name, message }) => {
+			logger.error(`  ${name}:`, message);
+		});
+	}
+}
+
+export function jsonPrintLogs(data: WebSocket.RawData): void {
+	console.log(JSON.stringify(JSON.parse(data.toString()), null, 2));
+}
+
+function isRequestEvent(
+	event: TailEventMessage["event"]
+): event is RequestEvent {
+	return Boolean(event && "request" in event);
+}
+
+function isScheduledEvent(
+	event: TailEventMessage["event"]
+): event is ScheduledEvent {
+	return Boolean(event && "cron" in event);
+}
+
+function isEmailEvent(event: TailEventMessage["event"]): event is EmailEvent {
+	return Boolean(event && "mailFrom" in event);
+}
+
+/**
+ * Check to see if an event sent from a worker is an AlarmEvent.
+ *
+ * Because the only property on `AlarmEvent` is "scheduledTime", which it
+ * shares with `ScheduledEvent`, `isAlarmEvent` checks if there's _not_
+ * a "cron" property in `event` to confirm it's an alarm event.
+ *
+ * @param event An event
+ * @returns true if the event is an AlarmEvent
+ */
+function isAlarmEvent(event: TailEventMessage["event"]): event is AlarmEvent {
+	return Boolean(event && "scheduledTime" in event && !("cron" in event));
+}
+
+function isTailInfo(event: TailEventMessage["event"]): event is TailInfo {
+	return Boolean(event && "message" in event && "type" in event);
+}
+
+function prettifyOutcome(outcome: Outcome): string {
+	switch (outcome) {
+		case "ok":
+			return "Ok";
+		case "canceled":
+			return "Canceled";
+		case "exceededCpu":
+			return "Exceeded CPU Limit";
+		case "exceededMemory":
+			return "Exceeded Memory Limit";
+		case "exception":
+			return "Exception Thrown";
+		case "unknown":
+		default:
+			return "Unknown";
+	}
+}

package/src/traverse-module-graph.ts

@@ -0,0 +1,54 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import chalk from "chalk";
+import { logger } from "./logger";
+import { matchFiles, parseRules } from "./module-collection";
+import type { BundleResult } from "./bundle";
+import type { Config } from "./config";
+import type { Entry } from "./entry";
+
+async function getFiles(root: string, relativeTo: string): Promise<string[]> {
+	const files = [];
+	for (const file of await readdir(root, { withFileTypes: true })) {
+		if (file.isDirectory()) {
+			files.push(...(await getFiles(path.join(root, file.name), relativeTo)));
+		} else {
+			files.push(path.relative(relativeTo, path.join(root, file.name)));
+		}
+	}
+	return files;
+}
+
+export default async function traverseModuleGraph(
+	entry: Entry,
+	rules: Config["rules"]
+): Promise<BundleResult> {
+	const files = await getFiles(entry.moduleRoot, entry.moduleRoot);
+	const relativeEntryPoint = path.relative(entry.moduleRoot, entry.file);
+
+	const modules = (await matchFiles(files, entry.moduleRoot, parseRules(rules)))
+		.filter((m) => m.name !== relativeEntryPoint)
+		.map((m) => ({
+			...m,
+			name: m.name,
+		}));
+
+	const bundleType = entry.format === "modules" ? "esm" : "commonjs";
+
+	if (modules.length > 0) {
+		logger.info(`Uploading additional modules:`);
+		modules.forEach(({ name, type }) => {
+			logger.info(`- ${chalk.blue(name)} (${chalk.green(type ?? "")})`);
+		});
+	}
+
+	return {
+		modules,
+		dependencies: {},
+		resolvedEntryPointPath: entry.file,
+		bundleType,
+		stop: undefined,
+		sourceMapPath: undefined,
+		sourceMapMetadata: undefined,
+	};
+}

package/src/tsconfig-sanity.ts

@@ -0,0 +1,16 @@
+// `@types/node` should be included
+Buffer.from("test");
+
+// @ts-expect-error `@types/jest` should NOT be included
+test("test");
+
+// @ts-expect-error `@cloudflare/workers-types` should NOT be included
+const _handler: ExportedHandler = {};
+// @ts-expect-error `@cloudflare/workers-types` should NOT be included
+new HTMLRewriter();
+
+// @ts-expect-error `fetch` should NOT be included as our minimum supported
+//  Node version is 16.13.0 which does not include `fetch` on the global scope
+void fetch("http://localhost/");
+
+export {};

package/src/type-generation.ts

@@ -0,0 +1,187 @@
+import * as fs from "fs";
+import { findUpSync } from "find-up";
+import { getEntry } from "./entry";
+import { logger } from "./logger";
+import type { Config } from "./config";
+
+// Currently includes bindings & rules for declaring modules
+
+export async function generateTypes(
+	configToDTS: Partial<Config>,
+	config: Config
+) {
+	const entry = await getEntry({}, config, "types");
+	const envTypeStructure: string[] = [];
+
+	if (configToDTS.kv_namespaces) {
+		for (const kvNamespace of configToDTS.kv_namespaces) {
+			envTypeStructure.push(`${kvNamespace.binding}: KVNamespace;`);
+		}
+	}
+
+	if (configToDTS.vars) {
+		for (const varName in configToDTS.vars) {
+			const varValue = configToDTS.vars[varName];
+			if (
+				typeof varValue === "string" ||
+				typeof varValue === "number" ||
+				typeof varValue === "boolean"
+			) {
+				envTypeStructure.push(`${varName}: "${varValue}";`);
+			}
+			if (typeof varValue === "object" && varValue !== null) {
+				envTypeStructure.push(`${varName}: ${JSON.stringify(varValue)};`);
+			}
+		}
+	}
+
+	if (configToDTS.durable_objects?.bindings) {
+		for (const durableObject of configToDTS.durable_objects.bindings) {
+			envTypeStructure.push(`${durableObject.name}: DurableObjectNamespace;`);
+		}
+	}
+
+	if (configToDTS.r2_buckets) {
+		for (const R2Bucket of configToDTS.r2_buckets) {
+			envTypeStructure.push(`${R2Bucket.binding}: R2Bucket;`);
+		}
+	}
+
+	if (configToDTS.d1_databases) {
+		for (const d1 of configToDTS.d1_databases) {
+			envTypeStructure.push(`${d1.binding}: D1Database;`);
+		}
+	}
+
+	if (configToDTS.services) {
+		for (const service of configToDTS.services) {
+			envTypeStructure.push(`${service.binding}: Fetcher;`);
+		}
+	}
+
+	if (configToDTS.constellation) {
+		for (const service of configToDTS.constellation) {
+			envTypeStructure.push(`${service.binding}: Fetcher;`);
+		}
+	}
+
+	if (configToDTS.analytics_engine_datasets) {
+		for (const analyticsEngine of configToDTS.analytics_engine_datasets) {
+			envTypeStructure.push(
+				`${analyticsEngine.binding}: AnalyticsEngineDataset;`
+			);
+		}
+	}
+
+	if (configToDTS.dispatch_namespaces) {
+		for (const namespace of configToDTS.dispatch_namespaces) {
+			envTypeStructure.push(`${namespace.binding}: any;`);
+		}
+	}
+
+	if (configToDTS.logfwdr?.schema) {
+		envTypeStructure.push(`LOGFWDR_SCHEMA: any;`);
+	}
+
+	if (configToDTS.data_blobs) {
+		for (const dataBlobs in configToDTS.data_blobs) {
+			envTypeStructure.push(`${dataBlobs}: ArrayBuffer;`);
+		}
+	}
+
+	if (configToDTS.text_blobs) {
+		for (const textBlobs in configToDTS.text_blobs) {
+			envTypeStructure.push(`${textBlobs}: string;`);
+		}
+	}
+
+	if (configToDTS.unsafe?.bindings) {
+		for (const unsafe of configToDTS.unsafe.bindings) {
+			envTypeStructure.push(`${unsafe.name}: any;`);
+		}
+	}
+
+	if (configToDTS.queues) {
+		if (configToDTS.queues.producers) {
+			for (const queue of configToDTS.queues.producers) {
+				envTypeStructure.push(`${queue.binding}: Queue;`);
+			}
+		}
+	}
+
+	const modulesTypeStructure: string[] = [];
+	if (configToDTS.rules) {
+		const moduleTypeMap = {
+			Text: "string",
+			Data: "ArrayBuffer",
+			CompiledWasm: "WebAssembly.Module",
+		};
+		for (const ruleObject of configToDTS.rules) {
+			const typeScriptType =
+				moduleTypeMap[ruleObject.type as keyof typeof moduleTypeMap];
+			if (typeScriptType !== undefined) {
+				ruleObject.globs.forEach((glob) => {
+					modulesTypeStructure.push(`declare module "*.${glob
+						.split(".")
+						.at(-1)}" {
+	const value: ${typeScriptType};
+	export default value;
+}`);
+				});
+			}
+		}
+	}
+
+	writeDTSFile({
+		envTypeStructure,
+		modulesTypeStructure,
+		formatType: entry.format,
+	});
+}
+
+function writeDTSFile({
+	envTypeStructure,
+	modulesTypeStructure,
+	formatType,
+}: {
+	envTypeStructure: string[];
+	modulesTypeStructure: string[];
+	formatType: "modules" | "service-worker";
+}) {
+	const wranglerOverrideDTSPath = findUpSync("worker-configuration.d.ts");
+	try {
+		if (
+			wranglerOverrideDTSPath !== undefined &&
+			!fs
+				.readFileSync(wranglerOverrideDTSPath, "utf8")
+				.includes("Generated by Wrangler")
+		) {
+			throw new Error(
+				"A non-wrangler worker-configuration.d.ts already exists, please rename and try again."
+			);
+		}
+	} catch (error) {
+		if (error instanceof Error && !error.message.includes("not found")) {
+			throw error;
+		}
+	}
+
+	let combinedTypeStrings = "";
+	if (formatType === "modules") {
+		combinedTypeStrings += `interface Env {\n${envTypeStructure
+			.map((value) => `\t${value}`)
+			.join("\n")}\n}\n${modulesTypeStructure.join("\n")}`;
+	} else {
+		combinedTypeStrings += `export {};\ndeclare global {\n${envTypeStructure
+			.map((value) => `\tconst ${value}`)
+			.join("\n")}\n}\n${modulesTypeStructure.join("\n")}`;
+	}
+
+	if (envTypeStructure.length || modulesTypeStructure.length) {
+		fs.writeFileSync(
+			"worker-configuration.d.ts",
+			`// Generated by Wrangler on ${new Date()}` + "\n" + combinedTypeStrings
+		);
+		logger.log(combinedTypeStrings);
+	}
+}

package/src/update-check.ts

@@ -0,0 +1,19 @@
+import chalk from "chalk";
+import checkForUpdate from "update-check";
+import pkg from "../package.json";
+
+export async function updateCheck(): Promise<string> {
+	let update = null;
+	try {
+		// default cache for update check is 1 day
+		update = await checkForUpdate(pkg, {
+			distTag: pkg.version.startsWith("0.0.0") ? "beta" : "latest",
+		});
+	} catch (err) {
+		// ignore error
+	}
+
+	if (update) return `(update available ${chalk.green(update.latest)})`;
+
+	return "";
+}

package/src/user/access.ts

@@ -0,0 +1,68 @@
+import { spawnSync } from "child_process";
+import { fetch } from "undici";
+import { logger } from "../logger";
+
+const cache: Record<string, string> = {};
+
+const usesAccessCache = new Map();
+
+export async function domainUsesAccess(domain: string): Promise<boolean> {
+	logger.debug("Checking if domain has Access enabled:", domain);
+
+	if (usesAccessCache.has(domain)) {
+		logger.debug(
+			"Using cached Access switch for:",
+			domain,
+			usesAccessCache.get(domain)
+		);
+		return usesAccessCache.get(domain);
+	}
+	logger.debug("Access switch not cached for:", domain);
+	try {
+		const controller = new AbortController();
+		const cancel = setTimeout(() => {
+			controller.abort();
+		}, 1000);
+
+		const output = await fetch(`https://${domain}`, {
+			redirect: "manual",
+			signal: controller.signal,
+		});
+		clearTimeout(cancel);
+		const usesAccess = !!(
+			output.status === 302 &&
+			output.headers.get("location")?.includes("cloudflareaccess.com")
+		);
+		logger.debug("Caching access switch for:", domain);
+
+		usesAccessCache.set(domain, usesAccess);
+		return usesAccess;
+	} catch (e) {
+		usesAccessCache.set(domain, false);
+		return false;
+	}
+}
+export async function getAccessToken(
+	domain: string
+): Promise<string | undefined> {
+	if (!(await domainUsesAccess(domain))) {
+		return undefined;
+	}
+	if (cache[domain]) {
+		return cache[domain];
+	}
+	const output = await spawnSync("cloudflared", ["access", "login", domain]);
+	if (output.error) {
+		// The cloudflared binary is not installed
+		throw new Error(
+			"To use Wrangler with Cloudflare Access, please install `cloudflared` from https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation"
+		);
+	}
+	const stringOutput = output.stdout.toString();
+	const matches = stringOutput.match(/fetched your token:\n\n(.*)/m);
+	if (matches && matches.length >= 2) {
+		cache[domain] = matches[1];
+		return matches[1];
+	}
+	throw new Error("Failed to authenticate with Cloudflare Access");
+}