devflare 1.0.0-next.5 → 1.0.0-next.50

package/dist/_chunks/productions-T9Als4fE.js

@@ -0,0 +1,411 @@
+import { r as loadConfig, t as ConfigNotFoundError } from "./loader-Cr0_OWPy.js";
+import { t as account } from "./cloudflare-BaloqI3H.js";
+import { a as cyanBold, d as green, f as logLine, g as yellow, h as whiteDim, l as formatLabelValue, m as red, n as bold, o as dim, p as logTable, r as createCliTheme } from "./ui-BUoZApvE.js";
+import { i as findFiles } from "./glob-CmQOvunB.js";
+import { i as resolveNamedSelection, r as resolveCloudflareAccountId, t as asOptionalString } from "./command-utils-DA0Qx9_K.js";
+import { t as getDependencies } from "./dependencies-C2oxFjU_.js";
+import { i as collectConfiguredWorkerFamilies } from "./family-_9-mGSfO.js";
+//#region src/cli/commands/productions.ts
+const CLI_API_OPTIONS = { timeout: 1e4 };
+const PRODUCTION_SUBCOMMANDS = [
+	"list",
+	"versions",
+	"rollback",
+	"delete"
+];
+const VERSION_LIST_LIMIT = 10;
+function isProductionSubcommand(value) {
+	return PRODUCTION_SUBCOMMANDS.includes(value);
+}
+function shortenVersionId(versionId, length = 12) {
+	return versionId.length <= length ? versionId : `${versionId.slice(0, length)}…`;
+}
+function selectDeploymentVersionId(deployment) {
+	return deployment.versions.find((version) => version.percentage === 100)?.versionId ?? deployment.versions[0]?.versionId;
+}
+function getWorkerVersionTimestamp(version) {
+	return version.metadata.modifiedOn ?? version.metadata.createdOn;
+}
+function formatRecordDate(date) {
+	return date ? date.toISOString().slice(0, 19).replace("T", " ") : "N/A";
+}
+function formatWorkerStatus(status, theme) {
+	switch (status) {
+		case "active": return green(status, theme);
+		case "undeployed": return yellow(status, theme);
+		default: return red(status, theme);
+	}
+}
+function formatVersionStatus(status, theme) {
+	switch (status) {
+		case "active": return green(status, theme);
+		default: return whiteDim(status, theme);
+	}
+}
+function shouldReplaceConfiguredWorkerFamily(existing, candidate) {
+	return !existing || candidate.role === "primary" && existing.role !== "primary";
+}
+function mergeConfiguredWorkerFamily(families, candidate) {
+	if (shouldReplaceConfiguredWorkerFamily(families.get(candidate.baseName), candidate)) families.set(candidate.baseName, candidate);
+}
+async function discoverProductionConfigs(cwd, configFile, environment) {
+	const families = /* @__PURE__ */ new Map();
+	const primaryFamilyNames = /* @__PURE__ */ new Set();
+	const accountIds = /* @__PURE__ */ new Set();
+	let defaultWorkerName;
+	let defaultWorkerNameSource = "none";
+	const loadAndCollect = async (candidateConfigFile) => {
+		try {
+			const config = await loadConfig({
+				cwd,
+				configFile: candidateConfigFile
+			});
+			const resolvedFamilies = collectConfiguredWorkerFamilies(config, environment);
+			for (const family of resolvedFamilies) {
+				mergeConfiguredWorkerFamily(families, family);
+				if (family.role === "primary") primaryFamilyNames.add(family.baseName);
+			}
+			if (config.accountId?.trim()) accountIds.add(config.accountId.trim());
+			if (!defaultWorkerName) {
+				defaultWorkerName = resolvedFamilies.find((family) => family.role === "primary")?.baseName;
+				defaultWorkerNameSource = defaultWorkerName ? "config" : "none";
+			}
+			return true;
+		} catch (error) {
+			if (error instanceof ConfigNotFoundError) return false;
+			throw error;
+		}
+	};
+	if (configFile) await loadAndCollect(configFile);
+	else if (!await loadAndCollect()) {
+		const configPaths = (await findFiles("**/devflare.config.{ts,js,mjs,cjs}", {
+			cwd,
+			absolute: true
+		})).sort((left, right) => left.localeCompare(right));
+		for (const configPath of configPaths) await loadAndCollect(configPath);
+	}
+	if (accountIds.size > 1) throw new Error("Multiple Cloudflare account ids were discovered across local Devflare configs. Pass --account to select one account explicitly for `devflare productions`.");
+	return {
+		accountId: Array.from(accountIds)[0],
+		defaultWorkerName,
+		defaultWorkerNameSource,
+		families: Array.from(families.values()).sort((left, right) => {
+			if (left.role === "primary" && right.role !== "primary") return -1;
+			if (left.role !== "primary" && right.role === "primary") return 1;
+			return left.baseName.localeCompare(right.baseName);
+		}),
+		primaryFamilyNames: Array.from(primaryFamilyNames).sort((left, right) => left.localeCompare(right))
+	};
+}
+async function resolveAccountId(parsed, discovery) {
+	return resolveCloudflareAccountId({
+		explicitAccountId: asOptionalString(parsed.options.account),
+		configuredAccountId: discovery.accountId,
+		apiOptions: CLI_API_OPTIONS
+	});
+}
+function resolveWorkerName(parsed, discovery, fallbackArg) {
+	const selection = resolveNamedSelection({
+		explicitValue: asOptionalString(parsed.options.worker),
+		fallbackValue: fallbackArg,
+		configuredValue: discovery.defaultWorkerName
+	});
+	return {
+		workerName: selection.value,
+		source: selection.value === discovery.defaultWorkerName ? discovery.defaultWorkerNameSource : selection.source
+	};
+}
+async function resolveContext(parsed, options, subcommand, fallbackArg) {
+	const cwd = options.cwd ?? process.cwd();
+	const configFile = asOptionalString(parsed.options.config);
+	const environment = asOptionalString(parsed.options.env) ?? "production";
+	const explicitAccountId = asOptionalString(parsed.options.account);
+	const explicitWorkerName = asOptionalString(parsed.options.worker) ?? fallbackArg;
+	const discovery = Boolean(configFile) || !explicitAccountId || !explicitWorkerName ? await discoverProductionConfigs(cwd, configFile, environment) : {
+		accountId: void 0,
+		defaultWorkerName: void 0,
+		defaultWorkerNameSource: "none",
+		families: [],
+		primaryFamilyNames: []
+	};
+	const accountId = await resolveAccountId(parsed, discovery);
+	const workerSelection = resolveWorkerName(parsed, discovery, fallbackArg);
+	if (!accountId) throw new Error("No Cloudflare account could be resolved. Use --account or configure accountId in devflare.config.*.");
+	if ((subcommand === "rollback" || subcommand === "delete") && !workerSelection.workerName) throw new Error(`A worker name is required for productions ${subcommand}. Use --worker or run inside a configured package with a single primary worker.`);
+	return {
+		accountId,
+		workerName: workerSelection.workerName,
+		workerNameSource: workerSelection.source,
+		discovery
+	};
+}
+function getProductionUrl(workerName, workersSubdomain) {
+	if (!workersSubdomain) return;
+	return `https://${workerName}.${workersSubdomain.trim().replace(/^https?:\/\//i, "").replace(/\.workers\.dev\/?$/i, "")}.workers.dev`;
+}
+async function buildProductionRows(accountId, families, apiOptions) {
+	const [liveWorkers, workersSubdomain] = await Promise.all([account.workers(accountId, apiOptions), account.workersSubdomain(accountId, apiOptions)]);
+	const workersByName = new Map(liveWorkers.map((worker) => [worker.name, worker]));
+	return Promise.all(families.map(async (family) => {
+		const worker = workersByName.get(family.baseName);
+		if (!worker) return {
+			workerName: family.baseName,
+			role: family.roleLabel,
+			status: "missing",
+			url: getProductionUrl(family.baseName, workersSubdomain)
+		};
+		const latestDeployment = [...await account.workerDeployments(accountId, family.baseName, apiOptions)].sort((left, right) => {
+			return right.createdOn.getTime() - left.createdOn.getTime();
+		})[0];
+		const activeVersionId = latestDeployment ? selectDeploymentVersionId(latestDeployment) : void 0;
+		return {
+			workerName: family.baseName,
+			role: family.roleLabel,
+			status: latestDeployment ? "active" : "undeployed",
+			deployedAt: latestDeployment?.createdOn ?? worker.modifiedOn,
+			versionId: activeVersionId,
+			source: latestDeployment?.source,
+			url: getProductionUrl(family.baseName, workersSubdomain)
+		};
+	}));
+}
+function buildProductionColumns(theme) {
+	return [
+		{
+			label: "Worker",
+			width: 34,
+			value: (row) => row.workerName
+		},
+		{
+			label: "Role",
+			width: 18,
+			value: (row) => row.role
+		},
+		{
+			label: "Status",
+			width: 10,
+			value: (row) => formatWorkerStatus(row.status, theme)
+		},
+		{
+			label: "Deployed",
+			width: 19,
+			value: (row) => whiteDim(formatRecordDate(row.deployedAt), theme)
+		},
+		{
+			label: "Version",
+			width: 13,
+			value: (row) => row.versionId ? shortenVersionId(row.versionId) : dim("N/A", theme)
+		},
+		{
+			label: "Source",
+			width: 14,
+			value: (row) => row.source ?? dim("N/A", theme)
+		},
+		{
+			label: "URL",
+			value: (row) => row.url ?? "N/A"
+		}
+	];
+}
+function buildVersionColumns(theme) {
+	return [
+		{
+			label: "Version",
+			width: 13,
+			value: (row) => shortenVersionId(row.versionId)
+		},
+		{
+			label: "Status",
+			width: 8,
+			value: (row) => formatVersionStatus(row.status, theme)
+		},
+		{
+			label: "Updated",
+			width: 19,
+			value: (row) => whiteDim(formatRecordDate(row.updatedAt), theme)
+		},
+		{
+			label: "Last deployed",
+			width: 19,
+			value: (row) => whiteDim(formatRecordDate(row.deployedAt), theme)
+		},
+		{
+			label: "Source",
+			value: (row) => row.source ?? dim("N/A", theme)
+		}
+	];
+}
+async function loadWorkerVersionOverview(accountId, workerName, apiOptions) {
+	const [versions, deployments] = await Promise.all([account.workerVersions(accountId, workerName, apiOptions), account.workerDeployments(accountId, workerName, apiOptions)]);
+	const productionVersions = versions.filter((version) => version.id).filter((version) => version.metadata.hasPreview !== true).sort((left, right) => {
+		const leftTime = getWorkerVersionTimestamp(left)?.getTime() ?? 0;
+		return (getWorkerVersionTimestamp(right)?.getTime() ?? 0) - leftTime;
+	}).slice(0, VERSION_LIST_LIMIT);
+	const activeVersionIds = new Set((deployments[0]?.versions ?? []).map((version) => version.versionId));
+	const latestDeploymentByVersionId = /* @__PURE__ */ new Map();
+	for (const deployment of deployments) for (const version of deployment.versions) {
+		const existing = latestDeploymentByVersionId.get(version.versionId);
+		if (!existing || deployment.createdOn.getTime() > existing.getTime()) latestDeploymentByVersionId.set(version.versionId, deployment.createdOn);
+	}
+	return {
+		workerName,
+		rows: productionVersions.map((version) => ({
+			versionId: version.id,
+			status: activeVersionIds.has(version.id) ? "active" : "stored",
+			updatedAt: getWorkerVersionTimestamp(version),
+			deployedAt: latestDeploymentByVersionId.get(version.id),
+			source: version.metadata.source
+		}))
+	};
+}
+function showProductionOverview(logger, context, rows, theme) {
+	logLine(logger);
+	if (context.discovery.primaryFamilyNames.length === 1) {
+		logLine(logger, formatLabelValue("worker family", green(context.discovery.primaryFamilyNames[0], theme), theme));
+		logLine(logger, formatLabelValue("related", whiteDim(String(Math.max(context.discovery.families.length - 1, 0)), theme), theme));
+	} else if (context.discovery.primaryFamilyNames.length > 1) {
+		logLine(logger, formatLabelValue("configured", whiteDim(`${context.discovery.primaryFamilyNames.length} primary workers`, theme), theme));
+		logLine(logger, formatLabelValue("tracked", whiteDim(`${context.discovery.families.length} workers`, theme), theme));
+	} else if (context.workerName) logLine(logger, formatLabelValue("worker", green(context.workerName, theme), theme));
+	if (rows.length === 0) {
+		logLine(logger);
+		logLine(logger, dim("No production Workers matched the current selection.", theme));
+		logLine(logger);
+		return;
+	}
+	logLine(logger);
+	logTable(logger, {
+		title: "Productions",
+		rows,
+		columns: buildProductionColumns(theme),
+		theme,
+		titleAccent: "green"
+	});
+	logLine(logger);
+	logLine(logger, dim("Use `devflare productions versions` for recent production versions, or `rollback` / `delete` to mutate one Worker.", theme));
+	logLine(logger);
+}
+function showWorkerVersions(logger, overviews, theme) {
+	logLine(logger);
+	if (overviews.length === 0) {
+		logLine(logger, dim("No production versions were found for the current selection.", theme));
+		logLine(logger);
+		return;
+	}
+	for (const [index, overview] of overviews.entries()) {
+		if (index > 0) logLine(logger);
+		logLine(logger, `${bold("worker", theme)} ${green(overview.workerName, theme)}`);
+		if (overview.rows.length === 0) {
+			logLine(logger, dim("No stored production versions were found for this Worker.", theme));
+			continue;
+		}
+		logTable(logger, {
+			title: "Versions",
+			rows: overview.rows,
+			columns: buildVersionColumns(theme),
+			theme,
+			titleAccent: "cyan"
+		});
+	}
+	logLine(logger);
+}
+async function runRollback(context, parsed, options, logger, theme) {
+	if (!context.workerName) {
+		logger.error("A worker name is required for production rollback.");
+		return { exitCode: 1 };
+	}
+	const versionId = asOptionalString(parsed.options.version) || asOptionalString(parsed.options["version-id"]);
+	if (!(parsed.options.apply === true)) {
+		logger.success(`Production rollback dry run complete for ${context.workerName}`);
+		logger.info(versionId ? `Would roll back ${context.workerName} to version ${versionId}` : `Would roll back ${context.workerName} to the previously deployed production version`);
+		return { exitCode: 0 };
+	}
+	const rollbackMessage = asOptionalString(parsed.options.message) ?? `Rolled back ${context.workerName} via devflare productions rollback`;
+	const rollbackArgs = ["wrangler", "rollback"];
+	if (versionId) rollbackArgs.push(versionId);
+	rollbackArgs.push("--name", context.workerName, "--message", rollbackMessage);
+	logLine(logger);
+	logLine(logger, `${cyanBold("productions rollback", theme)} ${dim(`Rolling back ${context.workerName}`, theme)}`);
+	const deps = await getDependencies();
+	const cwd = options.cwd ?? process.cwd();
+	if ((await deps.exec.exec("bunx", rollbackArgs, {
+		cwd,
+		stdio: "inherit"
+	})).exitCode !== 0) {
+		logger.error(`Rollback failed for ${context.workerName}`);
+		return { exitCode: 1 };
+	}
+	const deployments = await account.workerDeployments(context.accountId, context.workerName, CLI_API_OPTIONS);
+	const activeVersionId = deployments[0] ? selectDeploymentVersionId(deployments[0]) : void 0;
+	logger.success(`Rolled back production deployment for ${context.workerName}`);
+	if (activeVersionId) logger.info(`Active version: ${activeVersionId}`);
+	return { exitCode: 0 };
+}
+async function runDelete(context, parsed, logger) {
+	if (!context.workerName) {
+		logger.error("A worker name is required for production deletion.");
+		return { exitCode: 1 };
+	}
+	if (!(parsed.options.apply === true)) {
+		logger.success(`Production delete dry run complete for ${context.workerName}`);
+		logger.info(`Would delete Worker script ${context.workerName}`);
+		logger.warn("Deleting a production Worker script does not automatically delete KV, D1, R2, queue, or other account resources.");
+		return { exitCode: 0 };
+	}
+	await account.deleteWorker(context.accountId, context.workerName, CLI_API_OPTIONS);
+	logger.success(`Deleted production Worker script ${context.workerName}`);
+	logger.warn("Devflare deleted the Worker script only. Review any shared account resources separately before cleaning them up.");
+	return { exitCode: 0 };
+}
+async function runProductionsCommand(parsed, logger, options) {
+	if (!await account.isAuthenticated()) {
+		logger.error("Not authenticated with Cloudflare");
+		logger.info("Run `devflare login` first.");
+		return { exitCode: 1 };
+	}
+	const rawSubcommand = parsed.args[0];
+	const fallbackWorkerArg = rawSubcommand && !isProductionSubcommand(rawSubcommand) ? rawSubcommand : parsed.args[1];
+	const subcommand = rawSubcommand && isProductionSubcommand(rawSubcommand) ? rawSubcommand : "list";
+	const theme = createCliTheme(parsed.options);
+	if (rawSubcommand && !isProductionSubcommand(rawSubcommand) && parsed.args.length > 2) {
+		logger.error(`Unknown productions subcommand: ${rawSubcommand}`);
+		logger.info(`Available productions subcommands: ${PRODUCTION_SUBCOMMANDS.join(", ")}`);
+		return { exitCode: 1 };
+	}
+	try {
+		const context = await resolveContext(parsed, options, subcommand, fallbackWorkerArg);
+		const selectedFamilies = context.discovery.families.length > 0 ? context.discovery.families : context.workerName ? [{
+			baseName: context.workerName,
+			roleLabel: "selected worker",
+			role: "primary"
+		}] : [];
+		switch (subcommand) {
+			case "versions": {
+				const workerNames = Array.from(new Set(context.workerName ? [context.workerName] : selectedFamilies.map((family) => family.baseName))).sort((left, right) => left.localeCompare(right));
+				if (workerNames.length === 0) {
+					logger.error("No production Workers could be resolved. Use --worker or run inside a configured package.");
+					return { exitCode: 1 };
+				}
+				showWorkerVersions(logger, await Promise.all(workerNames.map((workerName) => loadWorkerVersionOverview(context.accountId, workerName, CLI_API_OPTIONS))), theme);
+				return { exitCode: 0 };
+			}
+			case "rollback": return runRollback(context, parsed, options, logger, theme);
+			case "delete": return runDelete(context, parsed, logger);
+			default:
+				if (selectedFamilies.length === 0) {
+					logger.error("No production Workers could be resolved. Use --worker, --config, or run inside a configured package.");
+					return { exitCode: 1 };
+				}
+				showProductionOverview(logger, context, await buildProductionRows(context.accountId, selectedFamilies, CLI_API_OPTIONS), theme);
+				return { exitCode: 0 };
+		}
+	} catch (error) {
+		if (error instanceof Error) {
+			logger.error(error.message);
+			return { exitCode: 1 };
+		}
+		throw error;
+	}
+}
+//#endregion
+export { runProductionsCommand };

package/dist/_chunks/ref-CYJNAAe_.js

@@ -0,0 +1,178 @@
+//#region src/config/define.ts
+function defineConfig(config) {
+	if (typeof config === "function") {
+		const result = config();
+		if (result instanceof Promise) return result;
+		return result;
+	}
+	return config;
+}
+//#endregion
+//#region src/config/ref.ts
+const resolvedCache = /* @__PURE__ */ new WeakMap();
+const pendingResolutions = /* @__PURE__ */ new WeakMap();
+const PENDING_REF_VALUE = "<pending>";
+/**
+* Extract the import specifier string from an import-thunk function's source.
+*
+* Uses a narrow regex over `fn.toString()`. To avoid returning bogus paths for
+* minified or hand-written functions that do not contain a parseable
+* `import(...)` call, the result is validated before being returned.
+*
+* Throws a clear error instead of returning a silent placeholder when the
+* function source is not in a recognized shape.
+*/
+function extractConfigPathFromImportFn(fn) {
+	let source;
+	try {
+		source = Function.prototype.toString.call(fn);
+	} catch {
+		return PENDING_REF_VALUE;
+	}
+	if (!/import\s*\(/.test(source)) return PENDING_REF_VALUE;
+	const match = source.match(/import\s*\(\s*(['"`])([^'"`]+)\1\s*\)/);
+	const raw = match?.[2];
+	if (!raw || raw.length === 0) throw new Error("ref() could not extract a config path from the import function source. The specifier must be a static string literal — dynamic or computed specifiers (e.g. template literals with expressions) are not supported. If this input has been minified, pass an unminified config source.");
+	if (match?.[1] === "`" && /\$\{/.test(raw)) throw new Error("ref() import specifier is a template literal with an embedded expression. The specifier must be a static string literal so the config path can be resolved ahead of time.");
+	if (raw.length < 2 && !/[./]/.test(raw)) throw new Error(`ref() extracted a suspiciously short config path (${JSON.stringify(raw)}). This usually indicates a minified bundle where the original specifier was rewritten. Pass an unminified config source.`);
+	return raw;
+}
+function ref(nameOrImport, maybeImport) {
+	const nameOverride = typeof nameOrImport === "string" ? nameOrImport : void 0;
+	let importFn;
+	if (typeof nameOrImport === "function") importFn = nameOrImport;
+	else if (typeof maybeImport === "function") importFn = maybeImport;
+	if (!importFn) throw new Error("ref() requires an import function");
+	const resolvedImportFn = importFn;
+	const configPath = extractConfigPathFromImportFn(resolvedImportFn);
+	const doBindingCache = /* @__PURE__ */ new Map();
+	async function doResolve() {
+		const cached = resolvedCache.get(proxy);
+		if (cached) return cached;
+		const pending = pendingResolutions.get(proxy);
+		if (pending) return pending;
+		const trackedPromise = (async () => {
+			const module = await resolvedImportFn();
+			const config = "default" in module ? module.default : module;
+			if (!config.name && !nameOverride) throw new Error("Referenced config must have a \"name\" property");
+			const resolved = {
+				name: nameOverride ?? config.name,
+				config,
+				configPath
+			};
+			resolvedCache.set(proxy, resolved);
+			return resolved;
+		})().finally(() => {
+			pendingResolutions.delete(proxy);
+		});
+		pendingResolutions.set(proxy, trackedPromise);
+		return trackedPromise;
+	}
+	function getResolved() {
+		const cached = resolvedCache.get(proxy);
+		if (cached) return cached;
+		throw new Error("ref() not yet resolved. Call ref().resolve() first, or use top-level await in your config file to resolve all refs before exporting.");
+	}
+	function createWorkerBinding(entrypoint) {
+		return {
+			get service() {
+				const cached = resolvedCache.get(proxy);
+				if (cached) return cached.name;
+				if (nameOverride) return nameOverride;
+				return PENDING_REF_VALUE;
+			},
+			entrypoint,
+			__ref: proxy
+		};
+	}
+	const workerAccessor = new Proxy((entrypoint) => createWorkerBinding(entrypoint), { get(target, prop) {
+		if (prop === "service") {
+			const cached = resolvedCache.get(proxy);
+			if (cached) return cached.name;
+			if (nameOverride) return nameOverride;
+			return PENDING_REF_VALUE;
+		}
+		if (prop === "entrypoint") return void 0;
+		if (prop === "__ref") return proxy;
+		return Reflect.get(target, prop);
+	} });
+	function createDOBinding(bindingName) {
+		const cachedBinding = doBindingCache.get(bindingName);
+		if (cachedBinding) return cachedBinding;
+		const doBinding = {
+			get className() {
+				const cached = resolvedCache.get(proxy);
+				if (cached?.config.bindings?.durableObjects) {
+					const doConfig = cached.config.bindings.durableObjects[bindingName];
+					if (typeof doConfig === "string") return doConfig;
+					if (doConfig && typeof doConfig === "object" && "className" in doConfig) return doConfig.className;
+				}
+				return PENDING_REF_VALUE;
+			},
+			get scriptName() {
+				const cached = resolvedCache.get(proxy);
+				if (cached) return cached.name;
+				if (nameOverride) return nameOverride;
+				return PENDING_REF_VALUE;
+			},
+			kind: "cross-worker",
+			__ref: proxy
+		};
+		doBindingCache.set(bindingName, doBinding);
+		return doBinding;
+	}
+	const knownProps = new Set([
+		"name",
+		"config",
+		"configPath",
+		"worker",
+		"__import",
+		"__nameOverride",
+		"resolve",
+		"then"
+	]);
+	const proxy = new Proxy({
+		get name() {
+			return getResolved().name;
+		},
+		get config() {
+			return getResolved().config;
+		},
+		configPath,
+		worker: workerAccessor,
+		__import: resolvedImportFn,
+		__nameOverride: nameOverride,
+		resolve: doResolve
+	}, {
+		get(target, prop) {
+			if (typeof prop === "string" && knownProps.has(prop)) return Reflect.get(target, prop);
+			if (typeof prop === "symbol") return Reflect.get(target, prop);
+			if (typeof prop === "string" && /^[A-Z][A-Z0-9_]*$/.test(prop)) {
+				const cached = resolvedCache.get(proxy);
+				if (cached) {
+					const doBindings = cached.config.bindings?.durableObjects;
+					if (!doBindings || !(prop in doBindings)) return;
+				}
+				return createDOBinding(prop);
+			}
+			return Reflect.get(target, prop);
+		},
+		has(target, prop) {
+			if (typeof prop === "string") {
+				if (knownProps.has(prop)) return true;
+				if (/^[A-Z][A-Z0-9_]*$/.test(prop)) {
+					const cached = resolvedCache.get(proxy);
+					if (cached) {
+						const doBindings = cached.config.bindings?.durableObjects;
+						return !!doBindings && prop in doBindings;
+					}
+					return true;
+				}
+			}
+			return Reflect.has(target, prop);
+		}
+	});
+	return proxy;
+}
+//#endregion
+export { defineConfig as n, ref as t };

package/dist/_chunks/remote-CZnP-HLJ.js

@@ -0,0 +1,79 @@
+import { a as DIM, c as RESET, n as BOLD, o as GREEN, s as RED, u as YELLOW } from "./colors-DiK6wPJ5.js";
+import { n as enableRemoteMode, r as getEffectiveRemoteModeStatus, t as disableRemoteMode } from "./remote-config-D39BY9ji.js";
+//#region src/cli/commands/remote.ts
+function log(message = "") {
+	console.log(message);
+}
+function showStatus() {
+	const status = getEffectiveRemoteModeStatus();
+	log();
+	log(`${BOLD}Remote Test Mode${RESET}`);
+	log();
+	if (status.isActive) {
+		log(`  ${GREEN}●${RESET} ${BOLD}Enabled${RESET}`);
+		if (status.source === "env") {
+			log(`    Source: ${YELLOW}DEVFLARE_REMOTE${RESET} environment variable`);
+			log(`    ${DIM}(unset the variable to disable)${RESET}`);
+		} else {
+			log(`    Expires in ${status.remainingMinutes} minute(s)`);
+			log(`    ${DIM}At: ${status.expiresAt?.toLocaleTimeString()}${RESET}`);
+		}
+	} else {
+		log(`  ${DIM}○${RESET} Disabled`);
+		log(`    ${DIM}Remote-only tests (AI, Vectorize) will be skipped${RESET}`);
+	}
+	log();
+	log(`${DIM}Commands:${RESET}`);
+	log(`  devflare remote enable [minutes]  Enable for N minutes (default: 30)`);
+	log(`  devflare remote disable           Disable immediately`);
+	log(`  devflare remote status            Show current status`);
+	log();
+}
+function enable(inputMinutes) {
+	const actualMinutes = enableRemoteMode(inputMinutes);
+	const status = getEffectiveRemoteModeStatus();
+	log();
+	if (inputMinutes !== actualMinutes) log(`${YELLOW}⚠${RESET}  Invalid duration, using ${actualMinutes} minute(s)`);
+	log(`${GREEN}✓${RESET} Remote test mode ${BOLD}enabled${RESET} for ${actualMinutes} minute(s)`);
+	log(`  Expires at: ${status.expiresAt?.toLocaleTimeString()}`);
+	log();
+	log(`${YELLOW}⚠${RESET}  Remote tests use real Cloudflare infrastructure and may incur costs.`);
+	log(`   Run ${DIM}devflare remote disable${RESET} when done.`);
+	log();
+}
+function disable() {
+	const statusBefore = getEffectiveRemoteModeStatus();
+	disableRemoteMode();
+	log();
+	log(`${GREEN}✓${RESET} Remote test mode ${BOLD}disabled${RESET}`);
+	if (statusBefore.envVarSet) {
+		log();
+		log(`${YELLOW}⚠${RESET}  Note: ${BOLD}DEVFLARE_REMOTE${RESET} environment variable is still set.`);
+		log(`   Remote mode will remain active until you unset it.`);
+	} else log(`  Remote-only tests (AI, Vectorize) will now be skipped.`);
+	log();
+}
+function runRemoteCommand(parsed, _logger, _options) {
+	const subcommand = parsed.args[0];
+	const arg = parsed.args[1];
+	switch (subcommand) {
+		case "enable": {
+			const minutes = arg ? Number.parseInt(arg, 10) : 30;
+			enable(Number.isNaN(minutes) ? 30 : minutes);
+			return { exitCode: 0 };
+		}
+		case "disable":
+			disable();
+			return { exitCode: 0 };
+		case "status":
+		case void 0:
+			showStatus();
+			return { exitCode: 0 };
+		default:
+			log(`${RED}Unknown subcommand:${RESET} ${subcommand}`);
+			log(`Run ${DIM}devflare remote${RESET} for usage.`);
+			return { exitCode: 1 };
+	}
+}
+//#endregion
+export { runRemoteCommand };