wrangler 0.0.0-e351afcf → 0.0.0-e3990bbf

package/src/tail/index.ts

@@ -1,211 +0,0 @@
-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

@@ -1,122 +0,0 @@
-import { logger } from "../logger";
-import type {
-	AlarmEvent,
-	EmailEvent,
-	RequestEvent,
-	ScheduledEvent,
-	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 {
-		// 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 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

@@ -1,53 +0,0 @@
-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,
-	};
-}

package/src/tsconfig-sanity.ts

@@ -1,16 +0,0 @@
-// `@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

@@ -1,181 +0,0 @@
-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.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

@@ -1,19 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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");
-}