@cloudflare/vite-plugin 1.49.1 → 1.51.0

package/dist/index.mjs

@@ -31,6 +31,8 @@ import { getCloudflarePreset, nonPrefixedNodeModules } from "@cloudflare/unenv-p
 import process$1, { exit, stdin, stdout } from "node:process";
 import v8 from "node:v8";
 import { defineEnv } from "unenv";
+import os$1 from "os";
+import { execSync } from "child_process";
 import tty from "node:tty";
 import P from "node:readline";
 import { WebSocket, WebSocketServer } from "ws";
@@ -1487,7 +1489,7 @@ async function assertWranglerVersion() {
 * The default compatibility date to use when the user omits one.
 * This value is injected at build time and remains fixed for each release.
 */
-const DEFAULT_COMPAT_DATE = "2026-07-31";
+const DEFAULT_COMPAT_DATE = "2026-08-05";
 
 //#endregion
 //#region src/build-output-env.ts
@@ -26722,7 +26724,7 @@ var require_ci_info$1 = __commonJS$1({ "../../node_modules/.pnpm/ci-info@4.4.0/n
 } });
 var require_command_exists$2 = __commonJS$1({ "../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/lib/command-exists.js"(exports$2, module$1) {
 	var exec$3 = __require$1("child_process").exec;
-	var execSync$1 = __require$1("child_process").execSync;
+	var execSync$2 = __require$1("child_process").execSync;
 	var fs3 = __require$1("fs");
 	var path6 = __require$1("path");
 	var access$1 = fs3.access;
@@ -26778,7 +26780,7 @@ var require_command_exists$2 = __commonJS$1({ "../../node_modules/.pnpm/command-
 	}, "commandExistsWindows");
 	var commandExistsUnixSync$1 = /* @__PURE__ */ __name$4(function(commandName, cleanedCommandName) {
 		if (fileNotExistsSync$1(commandName)) try {
-			return !!execSync$1("command -v " + cleanedCommandName + " 2>/dev/null && { echo >&1 " + cleanedCommandName + "; exit 0; }");
+			return !!execSync$2("command -v " + cleanedCommandName + " 2>/dev/null && { echo >&1 " + cleanedCommandName + "; exit 0; }");
 		} catch (error51) {
 			return false;
 		}
@@ -26787,7 +26789,7 @@ var require_command_exists$2 = __commonJS$1({ "../../node_modules/.pnpm/command-
 	var commandExistsWindowsSync$1 = /* @__PURE__ */ __name$4(function(commandName, cleanedCommandName, callback$1) {
 		if (!/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-zA-Z]:)?(?:(?:[^<>:"\|\?\*\n])+(?:\/\/|\/|\\\\|\\)?)+$/m.test(commandName)) return false;
 		try {
-			return !!execSync$1("where " + cleanedCommandName, { stdio: [] });
+			return !!execSync$2("where " + cleanedCommandName, { stdio: [] });
 		} catch (error51) {
 			return false;
 		}
@@ -27620,6 +27622,17 @@ var require_update_check = __commonJS$1({ "../../node_modules/.pnpm/update-check
 		return null;
 	};
 } });
+var ARTIFACTS_EVENT_TYPES = [
+	"cf.artifacts.repo.created",
+	"cf.artifacts.repo.deleted",
+	"cf.artifacts.repo.forked",
+	"cf.artifacts.repo.imported",
+	"cf.artifacts.repo.pushed",
+	"cf.artifacts.repo.cloned",
+	"cf.artifacts.repo.fetched",
+	"cf.artifacts.repo.token.created",
+	"cf.artifacts.repo.token.revoked"
+];
 function getDurableObjectExports(exports$2) {
 	return partitionExports$1(exports$2)["durable-object"];
 }
@@ -41617,7 +41630,7 @@ var getLocalExplorerEnabledFromEnv = getBooleanEnvironmentVariableFactory({
 });
 var getLocalObservabilityEnabledFromEnv = getBooleanEnvironmentVariableFactory({
 	variableName: "X_LOCAL_OBSERVABILITY",
-	defaultValue: false
+	defaultValue: true
 });
 var getBrowserRenderingHeadfulFromEnv = getBooleanEnvironmentVariableFactory({
 	variableName: "X_BROWSER_HEADFUL",
@@ -42435,7 +42448,7 @@ function normalizeAndValidateEnvironment(diagnostics, configPath, rawEnv, isDisp
 		exports: inheritable(diagnostics, topLevelEnv, rawEnv, "exports", validateExports, {}),
 		kv_namespaces: notInheritable(diagnostics, topLevelEnv, rawConfig, rawEnv, envName, "kv_namespaces", validateBindingArray(envName, validateKVBinding), []),
 		cloudchamber: notInheritable(diagnostics, topLevelEnv, rawConfig, rawEnv, envName, "cloudchamber", validateCloudchamberConfig, {}),
-		containers: notInheritable(diagnostics, topLevelEnv, rawConfig, rawEnv, envName, "containers", validateContainerApp(envName, rawEnv.name, configPath), void 0),
+		containers: notInheritable(diagnostics, topLevelEnv, rawConfig, rawEnv, envName, "containers", validateContainerApp(envName, rawEnv.name ?? rawConfig?.name, configPath), void 0),
 		send_email: notInheritable(diagnostics, topLevelEnv, rawConfig, rawEnv, envName, "send_email", validateBindingArray(envName, validateSendEmailBinding), []),
 		queues: notInheritable(diagnostics, topLevelEnv, rawConfig, rawEnv, envName, "queues", validateQueues(envName), {
 			producers: [],
@@ -42498,9 +42511,10 @@ __name$4(validateAndNormalizeTsconfig, "validateAndNormalizeTsconfig");
 var validateAndNormalizeRules = /* @__PURE__ */ __name$4((diagnostics, topLevelEnv, rawEnv, envName) => {
 	return inheritable(diagnostics, topLevelEnv, rawEnv, "rules", validateRules(envName), []);
 }, "validateAndNormalizeRules");
+var ARTIFACTS_EVENT_TYPE_SET = new Set(ARTIFACTS_EVENT_TYPES);
 var validateTriggers = /* @__PURE__ */ __name$4((diagnostics, triggersFieldName, triggersValue) => {
 	if (triggersValue === void 0 || triggersValue === null) return true;
-	if (typeof triggersValue !== "object") {
+	if (typeof triggersValue !== "object" || Array.isArray(triggersValue)) {
 		diagnostics.errors.push(`Expected "${triggersFieldName}" to be of type object but got ${JSON.stringify(triggersValue)}.`);
 		return false;
 	}
@@ -42509,7 +42523,49 @@ var validateTriggers = /* @__PURE__ */ __name$4((diagnostics, triggersFieldName,
 		diagnostics.errors.push(`Expected "${triggersFieldName}.crons" to be of type array, but got ${JSON.stringify(triggersValue)}.`);
 		isValid = false;
 	}
-	isValid = validateAdditionalProperties(diagnostics, triggersFieldName, Object.keys(triggersValue), ["crons"]) && isValid;
+	if (hasProperty(triggersValue, "events") && !Array.isArray(triggersValue.events)) {
+		diagnostics.errors.push(`Expected "${triggersFieldName}.events" to be of type array, but got ${JSON.stringify(triggersValue)}.`);
+		isValid = false;
+	} else if (hasProperty(triggersValue, "events") && Array.isArray(triggersValue.events)) for (const [eventIndex, event] of triggersValue.events.entries()) {
+		const eventFieldName = `${triggersFieldName}.events[${eventIndex}]`;
+		if (typeof event !== "object" || event === null || Array.isArray(event)) {
+			diagnostics.errors.push(`Expected "${eventFieldName}" to be of type object, but got ${JSON.stringify(event)}.`);
+			isValid = false;
+			continue;
+		}
+		if (!isRequiredProperty(event, "type", "string") || !ARTIFACTS_EVENT_TYPE_SET.has(event.type)) {
+			diagnostics.errors.push(`Expected "${eventFieldName}.type" to be a supported Artifacts event type, but got ${JSON.stringify(event.type)}.`);
+			isValid = false;
+		}
+		if (hasProperty(event, "filter") && event.filter !== void 0) {
+			if (typeof event.filter !== "object" || event.filter === null || Array.isArray(event.filter)) {
+				diagnostics.errors.push(`Expected "${eventFieldName}.filter" to be of type object, but got ${JSON.stringify(event.filter)}.`);
+				isValid = false;
+			} else for (const [filterName, filterValue] of Object.entries(event.filter)) if (filterName !== "namespace" && filterName !== "repo_name" || typeof filterValue !== "string") {
+				diagnostics.errors.push(`Expected "${eventFieldName}.filter" to contain only string "namespace" and "repo_name" fields, but got ${JSON.stringify(event.filter)}.`);
+				isValid = false;
+				break;
+			}
+		}
+		if (!Array.isArray(event.targets) || event.targets.length === 0) {
+			diagnostics.errors.push(`Expected "${eventFieldName}.targets" to be a non-empty array, but got ${JSON.stringify(event.targets)}.`);
+			isValid = false;
+		} else for (const [targetIndex, target$1] of event.targets.entries()) {
+			const targetFieldName = `${eventFieldName}.targets[${targetIndex}]`;
+			if (typeof target$1 !== "object" || target$1 === null || Array.isArray(target$1) || target$1.type !== "workflow" || typeof target$1.workflow_name !== "string" || target$1.workflow_name.length === 0) {
+				diagnostics.errors.push(`Expected "${targetFieldName}" to be a workflow target with a non-empty "workflow_name", but got ${JSON.stringify(target$1)}.`);
+				isValid = false;
+				continue;
+			}
+			validateAdditionalProperties(diagnostics, targetFieldName, Object.keys(target$1), ["type", "workflow_name"]);
+		}
+		validateAdditionalProperties(diagnostics, eventFieldName, Object.keys(event), [
+			"type",
+			"filter",
+			"targets"
+		]);
+	}
+	isValid = validateAdditionalProperties(diagnostics, triggersFieldName, Object.keys(triggersValue), ["crons", "events"]) && isValid;
 	return isValid;
 }, "validateTriggers");
 var validateRules = /* @__PURE__ */ __name$4((envName) => (diagnostics, field, envValue, config2) => {
@@ -65476,6 +65532,480 @@ function createModuleReference(type, id) {
 	return `__CLOUDFLARE_MODULE__${type}__${id}__CLOUDFLARE_MODULE__`;
 }
 
+//#endregion
+//#region ../../node_modules/.pnpm/process-ancestry@0.1.0/node_modules/process-ancestry/dist/index.js
+function getProcessInfo(pid) {
+	try {
+		const output = execSync(`ps -p ${pid} -o pid=,ppid=,command=`, {
+			encoding: "utf8",
+			timeout: 5e3
+		}).trim();
+		if (!output) return null;
+		const [pidStr, ppidStr, ...commandParts] = output.split(/\s+/);
+		const parsedPid = pidStr ? parseInt(pidStr, 10) : NaN;
+		const parsedPpid = ppidStr ? parseInt(ppidStr, 10) : NaN;
+		if (isNaN(parsedPid) || isNaN(parsedPpid)) return null;
+		return {
+			pid: parsedPid,
+			ppid: parsedPpid,
+			command: commandParts.join(" ") || void 0
+		};
+	} catch (error$2) {
+		if (error$2 instanceof Error && error$2.message.includes("timeout")) console.warn(`Process lookup timed out for PID ${pid}`);
+		return null;
+	}
+}
+function getAncestryUnix(startPid) {
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	let currentPid = startPid;
+	let maxDepth = 1e3;
+	while (currentPid && maxDepth > 0) {
+		if (visited.has(currentPid)) {
+			console.warn(`Detected cycle in process tree at PID ${currentPid}`);
+			break;
+		}
+		visited.add(currentPid);
+		const info$1 = getProcessInfo(currentPid);
+		if (!info$1 || info$1.ppid === 0 || info$1.ppid === 1) break;
+		result.push(info$1);
+		currentPid = info$1.ppid;
+		maxDepth--;
+	}
+	if (maxDepth === 0) console.warn(`Reached maximum depth limit while traversing process tree from PID ${startPid}`);
+	return result;
+}
+function getProcessInfo2(pid) {
+	try {
+		const output = execSync(`wmic process where (ProcessId=${pid}) get ProcessId,ParentProcessId,CommandLine /format:csv`, {
+			encoding: "utf8",
+			timeout: 1e4
+		});
+		if (!output) return null;
+		const fields = output.split("\n").filter((line) => line.trim() && !line.startsWith("Node")).pop()?.split(",");
+		if (!fields || fields.length < 4) return null;
+		const [_node, commandLine, parentPid, thisPid] = fields;
+		const parsedPid = thisPid ? parseInt(thisPid.trim(), 10) : NaN;
+		const parsedPpid = parentPid ? parseInt(parentPid.trim(), 10) : NaN;
+		if (isNaN(parsedPid) || isNaN(parsedPpid)) return null;
+		return {
+			pid: parsedPid,
+			ppid: parsedPpid,
+			command: commandLine?.trim() || void 0
+		};
+	} catch (error$2) {
+		if (error$2 instanceof Error && error$2.message.includes("timeout")) console.warn(`Process lookup timed out for PID ${pid}`);
+		return null;
+	}
+}
+function getAncestryWindows(startPid) {
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	let currentPid = startPid;
+	let maxDepth = 1e3;
+	while (currentPid && maxDepth > 0) {
+		if (visited.has(currentPid)) {
+			console.warn(`Detected cycle in process tree at PID ${currentPid}`);
+			break;
+		}
+		visited.add(currentPid);
+		const info$1 = getProcessInfo2(currentPid);
+		if (!info$1 || info$1.ppid === 0 || info$1.ppid === 4) break;
+		result.push(info$1);
+		currentPid = info$1.ppid;
+		maxDepth--;
+	}
+	if (maxDepth === 0) console.warn(`Reached maximum depth limit while traversing process tree from PID ${startPid}`);
+	return result;
+}
+function getProcessAncestry(pid = process.pid) {
+	if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) throw new Error("PID must be a positive integer");
+	if (os$1.platform() === "win32") return getAncestryWindows(pid);
+	else return getAncestryUnix(pid);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/am-i-vibing@0.5.0/node_modules/am-i-vibing/dist/detector-1yx2Hoe0.mjs
+/**
+* Provider configurations for major AI coding tools
+*/
+const providers = [
+	{
+		id: "opencode",
+		name: "OpenCode",
+		type: "agent",
+		envVars: [{ any: [
+			"OPENCODE",
+			"OPENCODE_BIN_PATH",
+			"OPENCODE_SERVER",
+			"OPENCODE_APP_INFO",
+			"OPENCODE_MODES"
+		] }]
+	},
+	{
+		id: "jules",
+		name: "Jules",
+		type: "agent",
+		envVars: [{ all: [["HOME", "/home/jules"], ["USER", "swebot"]] }]
+	},
+	{
+		id: "claude-code",
+		name: "Claude Code",
+		type: "agent",
+		envVars: ["CLAUDECODE"]
+	},
+	{
+		id: "cursor-agent",
+		name: "Cursor Agent",
+		type: "agent",
+		envVars: [{ all: ["CURSOR_TRACE_ID", ["PAGER", "head -n 10000 | cat"]] }]
+	},
+	{
+		id: "cursor",
+		name: "Cursor",
+		type: "interactive",
+		envVars: ["CURSOR_TRACE_ID"]
+	},
+	{
+		id: "antigravity",
+		name: "Antigravity",
+		type: "agent",
+		envVars: [{ any: ["ANTIGRAVITY_AGENT", "ANTIGRAVITY_PROJECT_ID"] }]
+	},
+	{
+		id: "gemini-agent",
+		name: "Gemini CLI",
+		type: "agent",
+		envVars: [["GEMINI_CLI", "1"]],
+		processChecks: ["gemini"]
+	},
+	{
+		id: "codex",
+		name: "OpenAI Codex",
+		type: "agent",
+		envVars: ["CODEX_THREAD_ID"],
+		processChecks: ["codex"]
+	},
+	{
+		id: "replit",
+		name: "Replit",
+		type: "agent",
+		envVars: ["REPL_ID"]
+	},
+	{
+		id: "aider",
+		name: "Aider",
+		type: "agent",
+		envVars: ["AIDER_API_KEY"],
+		processChecks: ["aider"]
+	},
+	{
+		id: "bolt-agent",
+		name: "Bolt.new Agent",
+		type: "agent",
+		envVars: [{ all: [["SHELL", "/bin/jsh"], "npm_config_yes"] }]
+	},
+	{
+		id: "bolt",
+		name: "Bolt.new",
+		type: "interactive",
+		envVars: [{
+			all: [["SHELL", "/bin/jsh"]],
+			none: ["npm_config_yes"]
+		}]
+	},
+	{
+		id: "zed-agent",
+		name: "Zed Agent",
+		type: "agent",
+		envVars: [{ all: [["TERM_PROGRAM", "zed"], ["PAGER", "cat"]] }]
+	},
+	{
+		id: "zed",
+		name: "Zed",
+		type: "interactive",
+		envVars: [{
+			all: [["TERM_PROGRAM", "zed"]],
+			none: [["PAGER", "cat"]]
+		}]
+	},
+	{
+		id: "replit-assistant",
+		name: "Replit Assistant",
+		type: "agent",
+		envVars: [{ all: ["REPL_ID", ["REPLIT_MODE", "assistant"]] }]
+	},
+	{
+		id: "replit",
+		name: "Replit",
+		type: "interactive",
+		envVars: [{
+			all: ["REPL_ID"],
+			none: [["REPLIT_MODE", "assistant"]]
+		}]
+	},
+	{
+		id: "windsurf",
+		name: "Windsurf",
+		type: "agent",
+		envVars: ["CODEIUM_EDITOR_APP_ROOT"]
+	},
+	{
+		id: "crush",
+		name: "Crush",
+		type: "agent",
+		envVars: [{ any: [
+			["CRUSH", "1"],
+			["AGENT", "crush"],
+			["AI_AGENT", "crush"]
+		] }],
+		processChecks: ["crush"]
+	},
+	{
+		id: "amp",
+		name: "Amp",
+		type: "agent",
+		envVars: [{ any: ["AMP_CURRENT_THREAD_ID", ["AGENT", "amp"]] }]
+	},
+	{
+		id: "auggie",
+		name: "Auggie",
+		type: "agent",
+		envVars: [["AUGMENT_AGENT", "1"]]
+	},
+	{
+		id: "qwen-code",
+		name: "Qwen Code",
+		type: "agent",
+		envVars: [["QWEN_CODE", "1"]]
+	},
+	{
+		id: "vscode-copilot-agent",
+		name: "GitHub Copilot in VS Code",
+		type: "agent",
+		envVars: [{ all: [["TERM_PROGRAM", "vscode"], ["GIT_PAGER", "cat"]] }]
+	},
+	{
+		id: "warp",
+		name: "Warp Terminal",
+		type: "hybrid",
+		envVars: [{ all: [["TERM_PROGRAM", "WarpTerminal"]] }]
+	},
+	{
+		id: "octofriend",
+		name: "Octofriend",
+		type: "agent",
+		processChecks: ["octofriend"]
+	},
+	{
+		id: "devin",
+		name: "Devin",
+		type: "agent",
+		processChecks: ["devin"]
+	},
+	{
+		id: "droid",
+		name: "Factory Droid",
+		type: "agent",
+		processChecks: ["droid"]
+	},
+	{
+		id: "pi",
+		name: "Pi",
+		type: "agent",
+		envVars: [["PI_CODING_AGENT", "true"]]
+	}
+];
+/**
+* Check if a specific environment variable exists (handles both strings and tuples)
+*/
+function checkEnvVar(envVarDef, env$3 = process.env) {
+	const [envVar, expectedValue] = typeof envVarDef === "string" ? [envVarDef, void 0] : envVarDef;
+	const actualValue = env$3[envVar];
+	return Boolean(actualValue && (!expectedValue || actualValue === expectedValue));
+}
+/**
+* Check if a process is running in the process tree
+*/
+function checkProcess(processName, processAncestry) {
+	for (const ancestorProcess of processAncestry) if (ancestorProcess.command?.includes(processName)) return true;
+	return false;
+}
+/**
+* Check if an environment variable group matches based on its properties
+*/
+function checkEnvVars(definition, env$3 = process.env) {
+	if (typeof definition === "string" || Array.isArray(definition)) return checkEnvVar(definition, env$3);
+	const { any: any$1, all: all$1, none } = definition;
+	const anyResult = !any$1?.length || any$1.some((envVar) => checkEnvVar(envVar, env$3));
+	const allResult = !all$1?.length || all$1.every((envVar) => checkEnvVar(envVar, env$3));
+	const noneResult = !none?.length || !none.some((envVar) => checkEnvVar(envVar, env$3));
+	return anyResult && allResult && noneResult;
+}
+/**
+* Run custom detectors for a provider
+*/
+function runCustomDetectors(provider) {
+	return provider.customDetectors?.some((detector) => {
+		try {
+			return detector();
+		} catch {
+			return false;
+		}
+	}) ?? false;
+}
+/**
+* Create a positive detection result
+*/
+function createDetectedResult(provider) {
+	return {
+		isAgentic: true,
+		id: provider.id,
+		name: provider.name,
+		type: provider.type
+	};
+}
+/**
+* Normalize the various supported argument shapes into a DetectOptions object.
+*
+* Supported shapes:
+*   - detectAgenticEnvironment()
+*   - detectAgenticEnvironment(options)
+*   - detectAgenticEnvironment(env)                       // legacy
+*   - detectAgenticEnvironment(env, processAncestry)      // legacy
+*/
+function normalizeOptions(envOrOptions, legacyAncestry) {
+	if (envOrOptions != null && typeof envOrOptions === "object" && ("env" in envOrOptions || "processAncestry" in envOrOptions || "checkProcesses" in envOrOptions)) {
+		const opts = envOrOptions;
+		return {
+			env: opts.env ?? process.env,
+			processAncestry: opts.processAncestry,
+			checkProcesses: opts.checkProcesses ?? opts.processAncestry !== void 0
+		};
+	}
+	return {
+		env: envOrOptions ?? process.env,
+		processAncestry: legacyAncestry,
+		checkProcesses: legacyAncestry !== void 0
+	};
+}
+function detectAgenticEnvironment(envOrOptions, legacyAncestry) {
+	const { env: env$3, processAncestry, checkProcesses } = normalizeOptions(envOrOptions, legacyAncestry);
+	for (const provider of providers) if (provider.envVars?.some((group) => checkEnvVars(group, env$3))) return createDetectedResult(provider);
+	for (const provider of providers) if (runCustomDetectors(provider)) return createDetectedResult(provider);
+	if (checkProcesses) {
+		let cachedAncestry = processAncestry;
+		const getAncestry = () => {
+			if (cachedAncestry === void 0) try {
+				cachedAncestry = getProcessAncestry();
+			} catch {
+				cachedAncestry = [];
+			}
+			return cachedAncestry;
+		};
+		for (const provider of providers) if (provider.processChecks?.some((processName) => checkProcess(processName, getAncestry()))) return createDetectedResult(provider);
+	}
+	return {
+		isAgentic: false,
+		id: null,
+		name: null,
+		type: null
+	};
+}
+
+//#endregion
+//#region src/detect-agent.ts
+const NO_PROCESS_ANCESTRY = [];
+/**
+* Detects whether the current process is being driven by an AI coding agent.
+*
+* True only when the detected type is exactly `"agent"`. Hybrid terminals (Warp,
+* VS Code) embed agentic features but still have a human at the keyboard, so
+* they're treated as interactive — note `isAgent()` from the library would
+* report them as agents.
+*
+* Any error resolves to `false` rather than propagating.
+*/
+function isAgentSession() {
+	try {
+		return detectAgenticEnvironment({
+			env: process.env,
+			processAncestry: NO_PROCESS_ANCESTRY
+		}).type === "agent";
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/plugins/agent-hint.ts
+/**
+* Plugin that prints the Local Explorer API URL and useful routes when
+* the dev server is started by a headless AI agent. This allows agents
+* to discover and call the Local Explorer API programmatically.
+*
+* The hint is printed by patching `server.bindCLIShortcuts` so it
+* appears after both the server URLs and the keyboard shortcut hints.
+*/
+const agentHintPlugin = createPlugin("agent-hint", () => {
+	return {
+		configureServer(viteDevServer) {
+			maybeAddAgentHint(viteDevServer, "dev");
+		},
+		configurePreviewServer(vitePreviewServer) {
+			maybeAddAgentHint(vitePreviewServer, "preview");
+		}
+	};
+});
+/**
+* If the session is a headless AI agent with Local Explorer enabled,
+* patches `server.bindCLIShortcuts` to print the explorer API hint
+* after the shortcut hints have been printed.
+*
+* @param server - The Vite dev or preview server
+* @param mode - Whether this is a "dev" or "preview" session
+*/
+function maybeAddAgentHint(server, mode) {
+	if (process.stdin.isTTY || !getLocalExplorerEnabledFromEnv() || !isAgentSession()) return;
+	const originalBindCLIShortcuts = server.bindCLIShortcuts.bind(server);
+	server.bindCLIShortcuts = (options) => {
+		originalBindCLIShortcuts(options);
+		if (options?.print) printLocalExplorerAgentHint(server, mode);
+	};
+}
+/**
+* Prints the Local Explorer API URL and useful routes to stdout so that
+* headless AI agents can discover and call them programmatically.
+*
+* Keep the message in sync with the wrangler copy in
+* packages/wrangler/src/dev/start-dev.ts.
+*
+* @param server - The Vite dev or preview server (must have `resolvedUrls` populated)
+* @param mode - Whether this is a "dev" or "preview" session
+*/
+function printLocalExplorerAgentHint(server, mode) {
+	const url$2 = server.resolvedUrls?.local[0];
+	if (!url$2) return;
+	const explorerApiUrl = new URL(`${CorePaths.EXPLORER}/api`, url$2).href;
+	server.config.logger.info([
+		"",
+		`The Cloudflare Vite plugin detected this ${mode} session is running in an AI agent.`,
+		`The Local Explorer API is available at ${explorerApiUrl}`,
+		`Useful routes:`,
+		`  GET ${explorerApiUrl}/local/workers - local Workers and bindings`,
+		`  GET ${explorerApiUrl}/storage/kv/namespaces - KV namespaces`,
+		`  GET ${explorerApiUrl}/d1/database - D1 databases`,
+		`  GET ${explorerApiUrl}/r2/buckets - R2 buckets`,
+		`  GET ${explorerApiUrl}/workers/durable_objects/namespaces - Durable Object namespaces`,
+		`  GET ${explorerApiUrl}/workflows - Workflows`,
+		`  POST ${explorerApiUrl}/local/observability/query - run a read-only SQL query (SELECT/WITH only) over captured request traces and console logs. Tables: spans, logs (read attributes via json(attributes)). Example:`,
+		`    curl -X POST ${explorerApiUrl}/local/observability/query -H 'Content-Type: application/json' -d '{"sql":"SELECT service, name, outcome, duration_ms FROM spans WHERE parent_id IS NULL LIMIT 20"}'`,
+		`If the routes above don't cover what you need, fetch the full OpenAPI schema (large - use only as a last resort):`,
+		`  GET ${explorerApiUrl} - OpenAPI schema`,
+		""
+	].join("\n"));
+}
+
 //#endregion
 //#region src/cloudflare-environment.ts
 const MAIN_ENTRY_NAME = "index";
@@ -72389,7 +72919,7 @@ var __name$1 = (target$1, value) => __defProp$1(target$1, "name", {
 });
 
 //#endregion
-//#region ../workers-auth/dist/chunk-PBW6773T.mjs
+//#region ../workers-auth/dist/chunk-7AYQ2BAF.mjs
 var import_undici$2 = require_undici();
 var hasWarnedAboutDeprecatedV1ApiToken = false;
 function readStoredAuthState(options) {
@@ -72458,6 +72988,12 @@ function requireApiToken(options) {
 	return credentials;
 }
 __name$1(requireApiToken, "requireApiToken");
+var ACCOUNT_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+function validateAccountId(accountId, source) {
+	if (!ACCOUNT_ID_PATTERN.test(accountId)) throw new UserError(`Invalid account ID "${accountId}" ${source}. Account IDs may only contain alphanumeric characters, hyphens, and underscores.`, { telemetryMessage: "user account id invalid characters" });
+	return accountId;
+}
+__name$1(validateAccountId, "validateAccountId");
 var getAuthDomainFromEnv = getEnvironmentVariableFactory({
 	variableName: "WRANGLER_AUTH_DOMAIN",
 	defaultValue: /* @__PURE__ */ __name$1(() => getCloudflareApiEnvironmentFromEnv() === "staging" ? "dash.staging.cloudflare.com" : "dash.cloudflare.com", "defaultValue")
@@ -72474,10 +73010,21 @@ var getRevokeUrlFromEnv = getEnvironmentVariableFactory({
 	variableName: "WRANGLER_REVOKE_URL",
 	defaultValue: /* @__PURE__ */ __name$1(() => `https://${getAuthDomainFromEnv()}/oauth2/revoke`, "defaultValue")
 });
-var getCloudflareAccountIdFromEnv = getEnvironmentVariableFactory({
+var readCloudflareAccountIdFromEnv = getEnvironmentVariableFactory({
 	variableName: "CLOUDFLARE_ACCOUNT_ID",
 	deprecatedName: "CF_ACCOUNT_ID"
 });
+function getCloudflareAccountIdFromEnv() {
+	const accountId = readCloudflareAccountIdFromEnv();
+	if (!accountId) return;
+	return validateAccountId(accountId, "set in the `CLOUDFLARE_ACCOUNT_ID` environment variable");
+}
+__name$1(getCloudflareAccountIdFromEnv, "getCloudflareAccountIdFromEnv");
+var DEVICE_AUTH_PATH = "/oauth2/device/auth";
+function getDeviceAuthUrl() {
+	return `https://${getAuthDomainFromEnv()}${DEVICE_AUTH_PATH}`;
+}
+__name$1(getDeviceAuthUrl, "getDeviceAuthUrl");
 var getAccessClientIdFromEnv = getEnvironmentVariableFactory({ variableName: "CLOUDFLARE_ACCESS_CLIENT_ID" });
 var getAccessClientSecretFromEnv = getEnvironmentVariableFactory({ variableName: "CLOUDFLARE_ACCESS_CLIENT_SECRET" });
 var getCfAuthorizationTokenFromEnv = getEnvironmentVariableFactory({ variableName: "WRANGLER_CF_AUTHORIZATION_TOKEN" });
@@ -72623,6 +73170,26 @@ async function generatePKCECodes() {
 	};
 }
 __name$1(generatePKCECodes, "generatePKCECodes");
+var generateVerificationUrl = /* @__PURE__ */ __name$1(({ verificationUri, userCode }) => {
+	const url2 = new URL(verificationUri);
+	url2.searchParams.set("user_code", userCode);
+	return url2.toString();
+}, "generateVerificationUrl");
+function parseUrl(value) {
+	try {
+		return new URL(value);
+	} catch {
+		return;
+	}
+}
+__name$1(parseUrl, "parseUrl");
+function assertTrustedVerificationUrl(verificationUrl, options) {
+	const url2 = parseUrl(verificationUrl);
+	const expected = parseUrl(`https://${options.authDomain}`);
+	if (!(url2 !== void 0 && expected !== void 0 && url2.protocol === "https:" && url2.username === "" && url2.password === "" && url2.host === expected.host)) throw new UserError(`The authorization server returned an untrusted \`${options.field}\`: ${verificationUrl}
+Expected an \`https\` URL on \`${options.authDomain}\`. Refusing to display or open it.`, { telemetryMessage: "user device-flow untrusted verification url" });
+}
+__name$1(assertTrustedVerificationUrl, "assertTrustedVerificationUrl");
 var generateAuthUrl = /* @__PURE__ */ __name$1(({ authUrl, clientId, scopes, stateQueryParam, codeChallenge, redirectUri }) => {
 	return authUrl + `?response_type=code&client_id=${encodeURIComponent(clientId)}&redirect_uri=${encodeURIComponent(redirectUri)}&scope=${encodeURIComponent([...scopes, "offline_access"].join(" "))}&state=${stateQueryParam}&code_challenge=${encodeURIComponent(codeChallenge)}&code_challenge_method=S256`;
 }, "generateAuthUrl");
@@ -73276,6 +73843,228 @@ If you have changed the callback host or port because you are running in a conta
 	return Promise.race([timerPromise, loginPromise]);
 }
 __name$1(getOauthToken, "getOauthToken");
+var DEVICE_FLOW_MAX_DURATION_SECONDS = 300;
+var DEVICE_FLOW_MIN_POLL_INTERVAL_SECONDS = 1;
+function getStringMember(body, key) {
+	if (typeof body !== "object" || body === null) return;
+	const value = body[key];
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+__name$1(getStringMember, "getStringMember");
+function getPositiveNumberMember(body, key) {
+	if (typeof body !== "object" || body === null) return;
+	const value = body[key];
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+__name$1(getPositiveNumberMember, "getPositiveNumberMember");
+function describeUnusableResponse(response, body) {
+	const status$1 = `HTTP ${response.status} ${response.statusText}`.trim();
+	const description = getStringMember(body, "error_description");
+	return description ? `${status$1}: ${description}` : status$1;
+}
+__name$1(describeUnusableResponse, "describeUnusableResponse");
+function isRetryableStatus(status$1) {
+	return status$1 >= 500 || status$1 === 429;
+}
+__name$1(isRetryableStatus, "isRetryableStatus");
+function asDeviceAuthorizationResponse(body) {
+	const deviceCode = getStringMember(body, "device_code");
+	const userCode = getStringMember(body, "user_code");
+	const verificationUri = getStringMember(body, "verification_uri");
+	const expiresIn = getPositiveNumberMember(body, "expires_in");
+	if (!deviceCode || !userCode || !verificationUri || expiresIn === void 0) return;
+	return {
+		device_code: deviceCode,
+		user_code: userCode,
+		verification_uri: verificationUri,
+		verification_uri_complete: getStringMember(body, "verification_uri_complete"),
+		expires_in: expiresIn,
+		interval: getPositiveNumberMember(body, "interval")
+	};
+}
+__name$1(asDeviceAuthorizationResponse, "asDeviceAuthorizationResponse");
+async function readJson(response, logger$1) {
+	const text = await response.text();
+	try {
+		return JSON.parse(text);
+	} catch (e) {
+		if (text.match(/<!DOCTYPE html>/)) {
+			logger$1.debug("The body of the response was HTML rather than JSON. Check the debug logs to see the full body of the response.");
+			if (text.match(/challenge-platform/)) logger$1.debug(`It looks like you might have hit a bot challenge page. This may be transient but if not, please contact Cloudflare to find out what can be done. When you contact Cloudflare, please provide your Ray ID: ${response.headers.get("cf-ray")}`);
+		}
+		logger$1.debug("Full body of response\n\n", text);
+		throw new Error(`Invalid JSON in response: status: ${response.status} ${response.statusText}`, { cause: e });
+	}
+}
+__name$1(readJson, "readJson");
+async function buildDeviceAuthHeaders(logger$1, isNonInteractiveOrCI2) {
+	const headers = { "Content-Type": "application/x-www-form-urlencoded" };
+	if (await domainUsesAccess(getAuthDomainFromEnv(), logger$1)) {
+		logger$1.debug("Using Cloudflare Access to get an access token for the device authorization request");
+		Object.assign(headers, await getCloudflareAccessHeaders({
+			logger: logger$1,
+			isNonInteractiveOrCI: isNonInteractiveOrCI2
+		}));
+	}
+	return headers;
+}
+__name$1(buildDeviceAuthHeaders, "buildDeviceAuthHeaders");
+async function requestDeviceAuthorization(scopes, clientId, logger$1, isNonInteractiveOrCI2) {
+	const params = new URLSearchParams({
+		client_id: clientId,
+		scope: [...scopes, "offline_access"].join(" ")
+	});
+	const headers = await buildDeviceAuthHeaders(logger$1, isNonInteractiveOrCI2);
+	const deviceAuthUrl = getDeviceAuthUrl();
+	logger$1.debug("Fetching device authorization from", deviceAuthUrl);
+	const response = await (0, import_undici$2.fetch)(deviceAuthUrl, {
+		method: "POST",
+		body: params.toString(),
+		headers
+	});
+	if (!response.ok) {
+		const body2 = await readJson(response, logger$1).catch(() => void 0);
+		throw toErrorClass(body2 && typeof body2 === "object" && "error" in body2 ? String(body2.error) : `HTTP ${response.status} ${response.statusText}`);
+	}
+	const body = await readJson(response, logger$1);
+	const deviceAuth = asDeviceAuthorizationResponse(body);
+	if (deviceAuth === void 0) {
+		logger$1.debug("Unusable device authorization response body:", body);
+		throw new UserError(`The device authorization endpoint returned a response that could not be interpreted (${describeUnusableResponse(response, body)}).
+Enable debug logging to see the full response.`, { telemetryMessage: "user device-flow unusable device authorization response" });
+	}
+	return deviceAuth;
+}
+__name$1(requestDeviceAuthorization, "requestDeviceAuthorization");
+async function pollDeviceToken(deviceCode, clientId, logger$1, isNonInteractiveOrCI2) {
+	const response = await fetchAuthToken(new URLSearchParams({
+		grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+		device_code: deviceCode,
+		client_id: clientId
+	}), logger$1, isNonInteractiveOrCI2);
+	const body = await readJson(response, logger$1);
+	const error$2 = getStringMember(body, "error");
+	if (error$2 !== void 0) return {
+		kind: "oauth-error",
+		error: error$2
+	};
+	const accessToken = getStringMember(body, "access_token");
+	const expiresIn = getPositiveNumberMember(body, "expires_in");
+	if (!response.ok || accessToken === void 0 || expiresIn === void 0) {
+		logger$1.debug("Unusable token response body:", body);
+		return {
+			kind: "unexpected",
+			detail: describeUnusableResponse(response, body),
+			retryable: !response.ok && isRetryableStatus(response.status)
+		};
+	}
+	return {
+		kind: "token",
+		grant: {
+			access_token: accessToken,
+			expires_in: expiresIn,
+			refresh_token: getStringMember(body, "refresh_token"),
+			scope: getStringMember(body, "scope")
+		}
+	};
+}
+__name$1(pollDeviceToken, "pollDeviceToken");
+function sleep(seconds) {
+	return new Promise((resolve$4) => setTimeout(resolve$4, seconds * 1e3));
+}
+__name$1(sleep, "sleep");
+async function getOauthTokenViaDeviceFlow(options, ctx) {
+	const { logger: logger$1, openInBrowser: openInBrowser$1, isNonInteractiveOrCI: isNonInteractiveOrCI2 } = ctx;
+	const deviceAuth = await requestDeviceAuthorization(options.scopes, options.clientId, logger$1, isNonInteractiveOrCI2);
+	const authDomain = getAuthDomainFromEnv();
+	assertTrustedVerificationUrl(deviceAuth.verification_uri, {
+		field: "verification_uri",
+		authDomain
+	});
+	if (deviceAuth.verification_uri_complete !== void 0) assertTrustedVerificationUrl(deviceAuth.verification_uri_complete, {
+		field: "verification_uri_complete",
+		authDomain
+	});
+	const verificationUrl = deviceAuth.verification_uri_complete ?? generateVerificationUrl({
+		verificationUri: deviceAuth.verification_uri,
+		userCode: deviceAuth.user_code
+	});
+	const maxDurationSeconds = Math.min(deviceAuth.expires_in, DEVICE_FLOW_MAX_DURATION_SECONDS);
+	logger$1.log(esm_default`
+		To authorize ${ctx.displayName}, please visit:
+
+		  ${deviceAuth.verification_uri}
+
+		and enter the code:
+
+		  ${deviceAuth.user_code}
+
+		You have ${toHumanPeriod(maxDurationSeconds)} to approve this request.
+	`);
+	if (options.browser) {
+		logger$1.log(`
+Opening a link in your default browser: ${verificationUrl}`);
+		await openInBrowser$1(verificationUrl);
+	}
+	const deadline = Date.now() + maxDurationSeconds * 1e3;
+	let intervalSeconds = Math.max(deviceAuth.interval ?? DEVICE_FLOW_MIN_POLL_INTERVAL_SECONDS, DEVICE_FLOW_MIN_POLL_INTERVAL_SECONDS);
+	let firstPoll = true;
+	let lastPollFailure;
+	while (Date.now() < deadline) {
+		if (!firstPoll) await sleep(intervalSeconds);
+		firstPoll = false;
+		let result;
+		try {
+			result = await pollDeviceToken(deviceAuth.device_code, options.clientId, logger$1, isNonInteractiveOrCI2);
+		} catch (e) {
+			logger$1.debug("Ignoring transient error while polling for token:", e);
+			lastPollFailure = e instanceof Error ? e.message : String(e);
+			continue;
+		}
+		if (result.kind === "unexpected") {
+			if (!result.retryable) throw new UserError(`The token endpoint returned a response that could not be interpreted (${result.detail}).
+Enable debug logging to see the full response.`, { telemetryMessage: "user device-flow unusable token response" });
+			logger$1.debug("Ignoring transient response while polling for token:", result.detail);
+			lastPollFailure = result.detail;
+			continue;
+		}
+		lastPollFailure = void 0;
+		if (result.kind === "oauth-error") switch (result.error) {
+			case "authorization_pending": continue;
+			case "slow_down":
+				intervalSeconds += 5;
+				continue;
+			case "access_denied": throw new UserError(`Consent denied. You must grant consent to ${ctx.displayName} in order to login.
+If you don't want to do this consider passing an API token via the \`CLOUDFLARE_API_TOKEN\` environment variable.`, { telemetryMessage: "user device-flow consent denied" });
+			case "expired_token": throw new UserError(`Device code expired before the request was approved. Please run \`${ctx.deviceLoginCommand}\` again to obtain a new code.`, { telemetryMessage: "user device-flow code expired" });
+			default: throw toErrorClass(result.error);
+		}
+		const { grant } = result;
+		return {
+			token: {
+				value: grant.access_token,
+				expiry: new Date(Date.now() + grant.expires_in * 1e3).toISOString()
+			},
+			scopes: grant.scope ? grant.scope.split(" ") : [],
+			refreshToken: grant.refresh_token ? { value: grant.refresh_token } : void 0
+		};
+	}
+	if (lastPollFailure !== void 0) throw new UserError(`Gave up waiting for device authorization: the token endpoint kept returning responses that could not be interpreted (last: ${lastPollFailure}).
+Enable debug logging to see the full response, then run \`${ctx.deviceLoginCommand}\` to try again.`, { telemetryMessage: "user device-flow poll failed" });
+	throw new UserError(`Device authorization timed out after ${toHumanPeriod(maxDurationSeconds)}. Please run \`${ctx.deviceLoginCommand}\` again to obtain a new code.`, { telemetryMessage: "user device-flow authorization timeout" });
+}
+__name$1(getOauthTokenViaDeviceFlow, "getOauthTokenViaDeviceFlow");
+function toHumanPeriod(seconds) {
+	if (seconds < 60) return `${seconds} seconds`;
+	const minutes = Math.floor(seconds / 60);
+	const minutesPostfix = minutes === 1 ? "minute" : "minutes";
+	const remainingSeconds = seconds % 60;
+	const secondsPostfix = remainingSeconds === 1 ? "second" : "seconds";
+	if (remainingSeconds === 0) return `${minutes} ${minutesPostfix}`;
+	if (remainingSeconds == 59) return `${minutes + 1} ${minutesPostfix}`;
+	return `${minutes} ${minutesPostfix} and ${remainingSeconds} ${secondsPostfix}`;
+}
+__name$1(toHumanPeriod, "toHumanPeriod");
 function createOAuthFlow(ctx) {
 	const oauthFlowState = {};
 	const generators = {
@@ -73304,17 +74093,27 @@ function createOAuthFlow(ctx) {
 				OAuth login is not supported in the \`${complianceRegion}\` compliance region.
 				Please use a Cloudflare API token (\`CLOUDFLARE_API_TOKEN\` environment variable) or remove the ${props.complianceConfig?.compliance_region ? "`compliance_region` configuration property" : "`CLOUDFLARE_API_ENVIRONMENT` environment variable"}.
 			`, { telemetryMessage: "user login unsupported compliance region" });
-		ctx.logger.log("Attempting to login via OAuth...");
-		const oauth = await getOauthToken({
-			browser: props.browser ?? true,
-			scopes: props.scopes,
-			clientId: getClientId(),
-			redirectUri: ctx.redirectUri,
-			denied: consent.denied,
-			granted: consent.granted,
-			callbackHost: props.callbackHost ?? defaultCallbackHost,
-			callbackPort: props.callbackPort ?? defaultCallbackPort
-		}, oauthFlowState, ctx, generators);
+		let oauth;
+		if (props.device) {
+			ctx.logger.log("Attempting to login via OAuth Device Authorization Grant...");
+			oauth = await getOauthTokenViaDeviceFlow({
+				browser: props.browser ?? true,
+				scopes: props.scopes,
+				clientId: getClientId()
+			}, ctx);
+		} else {
+			ctx.logger.log("Attempting to login via OAuth...");
+			oauth = await getOauthToken({
+				browser: props.browser ?? true,
+				scopes: props.scopes,
+				clientId: getClientId(),
+				redirectUri: ctx.redirectUri,
+				denied: consent.denied,
+				granted: consent.granted,
+				callbackHost: props.callbackHost ?? defaultCallbackHost,
+				callbackPort: props.callbackPort ?? defaultCallbackPort
+			}, oauthFlowState, ctx, generators);
+		}
 		getStorage(props.profile).write({
 			oauth_token: oauth.token?.value ?? "",
 			expiration_time: oauth.token?.expiry,
@@ -75060,7 +75859,7 @@ function scrubEncryptedCredentials(options) {
 __name$1(scrubEncryptedCredentials, "scrubEncryptedCredentials");
 
 //#endregion
-//#region ../workers-auth/dist/chunk-RTFTHYPD.mjs
+//#region ../workers-auth/dist/chunk-AEOSGWMT.mjs
 function createPreferences(getConfigPath) {
 	function getUserPreferencesPath() {
 		return path2__default.resolve(getConfigPath(), "preferences.json");
@@ -75802,6 +76601,8 @@ Run \`${descriptor.commands.whoami}\` to check your current authentication statu
 		purgeOnLoginOrLogout: configCache.purgeConfigCaches,
 		clientId: descriptor.clientId,
 		consent: descriptor.consent,
+		displayName: descriptor.displayName,
+		deviceLoginCommand: descriptor.commands.deviceLogin,
 		redirectUri: descriptor.redirectUri,
 		storageFactory: credentialStorage.storageFactory,
 		allowGlobalAuthKey,
@@ -75844,7 +76645,8 @@ Run \`${descriptor.commands.whoami}\` to check your current authentication statu
 			browser: props?.browser ?? true,
 			callbackHost: props?.callbackHost,
 			callbackPort: props?.callbackPort,
-			profile: props?.profile
+			profile: props?.profile,
+			device: props?.device
 		};
 	}
 	__name$1(withDefaultScopes, "withDefaultScopes");
@@ -75936,7 +76738,7 @@ Alternatively, try running \`${descriptor.commands.login}\` to re-authenticate.`
 	function getActiveAccountId(config$2) {
 		const temporaryAccount = oauthFlow.getActiveTemporaryAccount();
 		if (temporaryAccount) return temporaryAccount.account.id;
-		if (config$2.account_id) return config$2.account_id;
+		if (config$2.account_id) return validateAccountId(config$2.account_id, `set as \`account_id\` in your ${descriptor.getConfigFileLabel()} file`);
 		const envAccountId = getCloudflareAccountIdFromEnv();
 		if (envAccountId) return envAccountId;
 		return getAccountFromCache()?.id;
@@ -76188,6 +76990,7 @@ __name$1(createAuthConfigFileHelpers, "createAuthConfigFileHelpers");
 //#region ../workers-auth/dist/cf/index.mjs
 var CF_KEYRING_SERVICE_NAME = "cloudflare";
 var CF_CLI_NAME = "cf";
+var CF_DISPLAY_NAME = "cf";
 var CF_OAUTH_CALLBACK_URL = "http://localhost:8877/oauth/callback";
 var CF_CONSENT_PAGES = {
 	granted: { url: "https://welcome.developers.workers.dev/cf-oauth-consent-granted" },
@@ -76325,10 +77128,12 @@ var { getAuthConfigFilePath: getAuthConfigFilePath$1, getEncryptedAuthConfigFile
 });
 var CF_CLI = {
 	cliName: CF_CLI_NAME,
+	displayName: CF_DISPLAY_NAME,
 	commands: {
 		login: "cf auth login",
 		whoami: "cf auth whoami",
-		createProfile: "cf auth create"
+		createProfile: "cf auth create",
+		deviceLogin: "cf auth login --device"
 	},
 	keyringServiceName: CF_KEYRING_SERVICE_NAME,
 	clientId: getClientIdFromEnv$1,
@@ -76414,6 +77219,7 @@ function validateScopeKeys(scopes) {
 __name$1(validateScopeKeys, "validateScopeKeys");
 var WRANGLER_KEYRING_SERVICE_NAME = "wrangler";
 var WRANGLER_CLI_NAME = "wrangler";
+var WRANGLER_DISPLAY_NAME = "Wrangler";
 var OAUTH_CALLBACK_URL = "http://localhost:8976/oauth/callback";
 var WRANGLER_CONSENT_PAGES = {
 	granted: { url: "https://welcome.developers.workers.dev/wrangler-oauth-consent-granted" },
@@ -76445,10 +77251,12 @@ var { getAuthConfigFilePath, getEncryptedAuthConfigFilePath, defaultAuthConfigSt
 });
 var WRANGLER_CLI = {
 	cliName: WRANGLER_CLI_NAME,
+	displayName: WRANGLER_DISPLAY_NAME,
 	commands: {
 		login: "wrangler login",
 		whoami: "wrangler whoami",
-		createProfile: "wrangler auth create"
+		createProfile: "wrangler auth create",
+		deviceLogin: "wrangler login --device"
 	},
 	keyringServiceName: WRANGLER_KEYRING_SERVICE_NAME,
 	clientId: getClientIdFromEnv,
@@ -76502,7 +77310,7 @@ var __name = (target$1, value) => __defProp(target$1, "name", {
 //#region ../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/lib/command-exists.js
 var require_command_exists$1 = /* @__PURE__ */ __commonJS$2({ "../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/lib/command-exists.js": ((exports, module) => {
 	var exec = __require$2("child_process").exec;
-	var execSync = __require$2("child_process").execSync;
+	var execSync$1 = __require$2("child_process").execSync;
 	var fs$2 = __require$2("fs");
 	var path = __require$2("path");
 	var access = fs$2.access;
@@ -76558,7 +77366,7 @@ var require_command_exists$1 = /* @__PURE__ */ __commonJS$2({ "../../node_module
 	};
 	var commandExistsUnixSync = function(commandName, cleanedCommandName) {
 		if (fileNotExistsSync(commandName)) try {
-			return !!execSync("command -v " + cleanedCommandName + " 2>/dev/null && { echo >&1 " + cleanedCommandName + "; exit 0; }");
+			return !!execSync$1("command -v " + cleanedCommandName + " 2>/dev/null && { echo >&1 " + cleanedCommandName + "; exit 0; }");
 		} catch (error$2) {
 			return false;
 		}
@@ -76567,7 +77375,7 @@ var require_command_exists$1 = /* @__PURE__ */ __commonJS$2({ "../../node_module
 	var commandExistsWindowsSync = function(commandName, cleanedCommandName, callback$1) {
 		if (!/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-zA-Z]:)?(?:(?:[^<>:"\|\?\*\n])+(?:\/\/|\/|\\\\|\\)?)+$/m.test(commandName)) return false;
 		try {
-			return !!execSync("where " + cleanedCommandName, { stdio: [] });
+			return !!execSync$1("where " + cleanedCommandName, { stdio: [] });
 		} catch (error$2) {
 			return false;
 		}
@@ -77480,7 +78288,7 @@ __name(createWorkerUploadForm, "createWorkerUploadForm");
 //#endregion
 //#region ../remote-bindings/dist/index.mjs
 var import_undici = require_undici();
-var version$2 = "0.0.5";
+var version$2 = "0.0.7";
 var NoDefaultValueProvided = class extends UserError {
 	constructor() {
 		super("This command cannot be run in a non-interactive context", { telemetryMessage: "remote bindings prompt default missing" });
@@ -82824,6 +83632,7 @@ function cloudflare(pluginConfig = {}) {
 		tunnelPlugin(ctx),
 		previewPlugin(ctx),
 		shortcutsPlugin(ctx),
+		agentHintPlugin(ctx),
 		debugPlugin(ctx),
 		triggerHandlersPlugin(ctx),
 		virtualModulesPlugin(ctx),