devflare 1.0.0-next.39 → 1.0.0-next.40

package/dist/_chunks/vite-utils-OVLMV605.js

@@ -0,0 +1,183 @@
+import { resolve } from "pathe";
+import { spawn } from "node:child_process";
+//#region src/dev-server/vite-utils.ts
+const VITE_CONFIG_FILES = [
+	"vite.config.ts",
+	"vite.config.js",
+	"vite.config.mts",
+	"vite.config.mjs",
+	"vite.config.cts",
+	"vite.config.cjs"
+];
+const ANSI_REGEX = /\x1b\[[0-9;]*m/g;
+const LOCAL_VITE_URL_REGEX = /https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\])(?::\d+)?\/?/i;
+async function getNodeFs() {
+	return await import("node:fs/promises");
+}
+function safeParsePackageJson(content) {
+	try {
+		return JSON.parse(content);
+	} catch {
+		return {};
+	}
+}
+function readDependencyFlag(pkg, name) {
+	const dependencies = pkg.dependencies;
+	const devDependencies = pkg.devDependencies;
+	return Boolean(dependencies?.[name] ?? devDependencies?.[name]);
+}
+async function detectViteProject(cwd, fs) {
+	const fileSystem = fs ?? await getNodeFs();
+	let viteConfigPath = null;
+	for (const configName of VITE_CONFIG_FILES) {
+		const absolutePath = resolve(cwd, configName);
+		try {
+			await fileSystem.access(absolutePath);
+			viteConfigPath = absolutePath;
+			break;
+		} catch {}
+	}
+	let pkg = {};
+	try {
+		pkg = safeParsePackageJson(await fileSystem.readFile(resolve(cwd, "package.json"), "utf-8"));
+	} catch {
+		pkg = {};
+	}
+	const hasLocalViteDependency = readDependencyFlag(pkg, "vite");
+	const hasLocalCloudflareVitePluginDependency = readDependencyFlag(pkg, "@cloudflare/vite-plugin");
+	return {
+		viteConfigPath,
+		hasLocalViteDependency,
+		hasLocalCloudflareVitePluginDependency,
+		shouldStartVite: Boolean(viteConfigPath),
+		wantsViteIntegration: Boolean(viteConfigPath || hasLocalViteDependency || hasLocalCloudflareVitePluginDependency)
+	};
+}
+/**
+* Resolve the effective Vite mode for a project. Combines the caller's
+* `requested` preference with the filesystem detection so that callers who ask
+* for Vite but lack a local config are downgraded to worker-only mode rather
+* than silently having the detection result ignored.
+*/
+async function resolveViteMode(cwd, options = {}) {
+	const detection = await detectViteProject(cwd, options.fs);
+	return {
+		enableVite: (options.requested ?? true) && detection.shouldStartVite,
+		viteConfigPath: detection.viteConfigPath,
+		detection
+	};
+}
+function stripAnsi(value) {
+	return value.replace(ANSI_REGEX, "");
+}
+function extractViteReadyUrl(output) {
+	const cleaned = stripAnsi(output);
+	const lines = cleaned.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+	for (const line of lines) {
+		if (!line.toLowerCase().includes("local:")) continue;
+		const match = line.match(LOCAL_VITE_URL_REGEX);
+		if (match) return match[0];
+	}
+	return cleaned.match(LOCAL_VITE_URL_REGEX)?.[0] ?? null;
+}
+async function waitForViteReady(process, options = {}) {
+	const { timeoutMs = 15e3, onStdout, onStderr } = options;
+	let combinedOutput = "";
+	return await new Promise((resolvePromise, rejectPromise) => {
+		let settled = false;
+		let timeout;
+		const settle = (resolver) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeout);
+			resolver();
+		};
+		const inspectChunk = (chunk) => {
+			combinedOutput += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+			const readyUrl = extractViteReadyUrl(combinedOutput);
+			if (readyUrl) settle(() => resolvePromise(readyUrl));
+		};
+		process.stdout?.on("data", (chunk) => {
+			onStdout?.(chunk);
+			inspectChunk(chunk);
+		});
+		process.stderr?.on("data", (chunk) => {
+			onStderr?.(chunk);
+			inspectChunk(chunk);
+		});
+		process.on("error", (error) => {
+			settle(() => rejectPromise(error));
+		});
+		process.on("exit", (code, signal) => {
+			settle(() => {
+				const reason = signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`;
+				rejectPromise(/* @__PURE__ */ new Error(`Vite exited before reporting a ready URL (${reason})`));
+			});
+		});
+		timeout = setTimeout(() => {
+			settle(() => resolvePromise(null));
+		}, timeoutMs);
+	});
+}
+async function defaultRunCommand(command, args) {
+	await new Promise((resolvePromise, rejectPromise) => {
+		const child = spawn(command, args, {
+			stdio: "ignore",
+			windowsHide: true
+		});
+		child.on("error", rejectPromise);
+		child.on("exit", () => resolvePromise());
+	});
+}
+function waitForProcessExit(process, timeoutMs) {
+	if (process.killed) return Promise.resolve(true);
+	return new Promise((resolvePromise) => {
+		let settled = false;
+		let timeout;
+		const settle = (value) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeout);
+			resolvePromise(value);
+		};
+		process.on("exit", () => settle(true));
+		timeout = setTimeout(() => {
+			settle(false);
+		}, timeoutMs);
+	});
+}
+async function stopSpawnedProcessTree(process, options = {}) {
+	const { platform = globalThis.process?.platform ?? "linux", timeoutMs = 3e3, runCommand = defaultRunCommand } = options;
+	if (platform === "win32" && process.pid) {
+		try {
+			await runCommand("taskkill", [
+				"/pid",
+				String(process.pid),
+				"/t",
+				"/f"
+			]);
+		} catch {
+			try {
+				process.kill("SIGTERM");
+			} catch {
+				return;
+			}
+		}
+		await waitForProcessExit(process, timeoutMs);
+		return;
+	}
+	try {
+		process.kill("SIGTERM");
+	} catch {
+		return;
+	}
+	if (await waitForProcessExit(process, timeoutMs)) return;
+	try {
+		process.kill("SIGKILL");
+	} catch {
+		return;
+	}
+	await waitForProcessExit(process, timeoutMs);
+}
+//#endregion
+export { waitForViteReady as i, resolveViteMode as n, stopSpawnedProcessTree as r, detectViteProject as t };

package/dist/_chunks/worker-CS1jgNFE.js

@@ -0,0 +1,410 @@
+import { r as loadConfig } from "./loader-DLXO60RO.js";
+import { o as normalizeDOBinding } from "./schema-normalization-DWVleVxo.js";
+import { t as account } from "./cloudflare-BaloqI3H.js";
+import { d as green, f as logLine, g as yellow, h as whiteDim, n as bold, o as dim, r as createCliTheme } from "./ui-BUoZApvE.js";
+import { r as resolveCloudflareAccountId, t as asOptionalString } from "./command-utils-BsfkmTqh.js";
+import { n as formatSupportedConfigFilenames, r as resolveConfigCandidatePath, t as findConfigPathsUnderDirectory } from "./config-path-DCPto4XB.js";
+import { basename, dirname, relative, resolve } from "pathe";
+import MagicString from "magic-string";
+//#region src/cli/commands/worker.ts
+function formatPathForLog(cwd, filePath) {
+	const relativePath = relative(cwd, filePath).replace(/\\/g, "/");
+	return relativePath && !relativePath.startsWith("..") ? relativePath : filePath;
+}
+async function loadConfigFromPath(configPath) {
+	return {
+		configPath,
+		config: await loadConfig({
+			cwd: dirname(configPath),
+			configFile: basename(configPath)
+		})
+	};
+}
+async function loadDiscoveredConfigs(cwd, explicitConfigPath) {
+	const candidatePaths = /* @__PURE__ */ new Set();
+	const discoveredPaths = await findConfigPathsUnderDirectory(cwd);
+	for (const configPath of discoveredPaths) candidatePaths.add(configPath);
+	if (explicitConfigPath) candidatePaths.add(explicitConfigPath);
+	const loadedConfigs = [];
+	for (const configPath of [...candidatePaths].sort((left, right) => left.localeCompare(right))) try {
+		loadedConfigs.push(await loadConfigFromPath(configPath));
+	} catch (error) {
+		if (explicitConfigPath && explicitConfigPath === configPath) throw error;
+	}
+	return loadedConfigs;
+}
+function formatConfigChoices(matches, cwd) {
+	return matches.map((match) => `  - ${formatPathForLog(cwd, match.configPath)} (${match.config.name})`).join("\n");
+}
+function selectTargetConfig(loadedConfigs, cwd, oldName, newName, explicitConfigPath) {
+	if (loadedConfigs.length === 0) throw new Error(`Could not find ${formatSupportedConfigFilenames()} under ${cwd}.`);
+	if (explicitConfigPath) {
+		const target = loadedConfigs.find((candidate) => candidate.configPath === explicitConfigPath);
+		if (!target) throw new Error(`Could not load the selected config: ${explicitConfigPath}`);
+		if (target.config.name === oldName) return {
+			target,
+			localConfigAlreadyUpdated: false,
+			allConfigs: loadedConfigs
+		};
+		if (target.config.name === newName) return {
+			target,
+			localConfigAlreadyUpdated: true,
+			allConfigs: loadedConfigs
+		};
+		throw new Error(`The selected config uses \`${target.config.name}\`, not \`${oldName}\` or \`${newName}\`.`);
+	}
+	const matchingConfigs = loadedConfigs.filter((candidate) => {
+		return candidate.config.name === oldName || candidate.config.name === newName;
+	});
+	const oldMatches = matchingConfigs.filter((candidate) => candidate.config.name === oldName);
+	const newMatches = matchingConfigs.filter((candidate) => candidate.config.name === newName);
+	if (oldMatches.length === 1 && matchingConfigs.length === 1) return {
+		target: oldMatches[0],
+		localConfigAlreadyUpdated: false,
+		allConfigs: loadedConfigs
+	};
+	if (newMatches.length === 1 && matchingConfigs.length === 1) return {
+		target: newMatches[0],
+		localConfigAlreadyUpdated: true,
+		allConfigs: loadedConfigs
+	};
+	if (matchingConfigs.length === 0) throw new Error(`Could not find a matching devflare config under ${cwd}. Expected a config whose \`name\` is \`${oldName}\` or \`${newName}\`.`);
+	throw new Error(`Multiple matching devflare configs were found. Use --config to pick one explicitly.\n${formatConfigChoices(matchingConfigs, cwd)}`);
+}
+async function resolveAccountId(parsed, config) {
+	return resolveCloudflareAccountId({
+		explicitAccountId: asOptionalString(parsed.options.account),
+		configuredAccountId: config.accountId
+	});
+}
+function skipWhitespaceAndComments(source, start, end) {
+	let index = start;
+	while (index < end) {
+		const char = source[index];
+		if (/\s/.test(char)) {
+			index++;
+			continue;
+		}
+		const nextIndex = consumeComment(source, index, end);
+		if (nextIndex !== null) {
+			index = nextIndex;
+			continue;
+		}
+		break;
+	}
+	return index;
+}
+function consumeQuotedLiteral(source, start, end) {
+	const quote = source[start];
+	let index = start + 1;
+	while (index < end) {
+		const char = source[index];
+		if (char === "\\") {
+			index += 2;
+			continue;
+		}
+		if (char === quote) return index + 1;
+		index++;
+	}
+	throw new Error("Unterminated string literal in devflare config.");
+}
+function consumeComment(source, start, end) {
+	if (source[start] !== "/") return null;
+	if (source[start + 1] === "/") {
+		let index = start + 2;
+		while (index < end && source[index] !== "\n") index++;
+		return index;
+	}
+	if (source[start + 1] === "*") {
+		let index = start + 2;
+		while (index < end && !(source[index] === "*" && source[index + 1] === "/")) index++;
+		return Math.min(index + 2, end);
+	}
+	return null;
+}
+function findConfigObjectStart(source) {
+	const defineConfigIndex = source.indexOf("defineConfig");
+	if (defineConfigIndex >= 0) {
+		const parenIndex = source.indexOf("(", defineConfigIndex);
+		if (parenIndex >= 0) {
+			const objectIndex = source.indexOf("{", parenIndex);
+			if (objectIndex >= 0) return objectIndex;
+		}
+	}
+	const exportDefaultIndex = source.indexOf("export default");
+	if (exportDefaultIndex >= 0) {
+		const objectIndex = source.indexOf("{", exportDefaultIndex);
+		if (objectIndex >= 0) return objectIndex;
+	}
+	return -1;
+}
+function getRootPropertySlices(source, objectStart) {
+	const slices = [];
+	let curlyDepth = 1;
+	let squareDepth = 0;
+	let parenDepth = 0;
+	let propertyStart = objectStart + 1;
+	let index = objectStart + 1;
+	while (index < source.length) {
+		const char = source[index];
+		if (char === "'" || char === "\"" || char === "`") {
+			index = consumeQuotedLiteral(source, index, source.length);
+			continue;
+		}
+		const nextIndex = consumeComment(source, index, source.length);
+		if (nextIndex !== null) {
+			index = nextIndex;
+			continue;
+		}
+		if (char === "{") {
+			curlyDepth++;
+			index++;
+			continue;
+		}
+		if (char === "}") {
+			curlyDepth--;
+			if (curlyDepth === 0) {
+				slices.push({
+					start: propertyStart,
+					end: index
+				});
+				return slices;
+			}
+			index++;
+			continue;
+		}
+		if (char === "[") {
+			squareDepth++;
+			index++;
+			continue;
+		}
+		if (char === "]") {
+			squareDepth--;
+			index++;
+			continue;
+		}
+		if (char === "(") {
+			parenDepth++;
+			index++;
+			continue;
+		}
+		if (char === ")") {
+			parenDepth--;
+			index++;
+			continue;
+		}
+		if (char === "," && curlyDepth === 1 && squareDepth === 0 && parenDepth === 0) {
+			slices.push({
+				start: propertyStart,
+				end: index
+			});
+			propertyStart = index + 1;
+		}
+		index++;
+	}
+	throw new Error("Could not parse the root object in devflare config.");
+}
+function findTopLevelColon(source, start, end) {
+	let curlyDepth = 0;
+	let squareDepth = 0;
+	let parenDepth = 0;
+	let index = start;
+	while (index < end) {
+		const char = source[index];
+		if (char === "'" || char === "\"" || char === "`") {
+			index = consumeQuotedLiteral(source, index, end);
+			continue;
+		}
+		const nextIndex = consumeComment(source, index, end);
+		if (nextIndex !== null) {
+			index = nextIndex;
+			continue;
+		}
+		if (char === "{") {
+			curlyDepth++;
+			index++;
+			continue;
+		}
+		if (char === "}") {
+			curlyDepth--;
+			index++;
+			continue;
+		}
+		if (char === "[") {
+			squareDepth++;
+			index++;
+			continue;
+		}
+		if (char === "]") {
+			squareDepth--;
+			index++;
+			continue;
+		}
+		if (char === "(") {
+			parenDepth++;
+			index++;
+			continue;
+		}
+		if (char === ")") {
+			parenDepth--;
+			index++;
+			continue;
+		}
+		if (char === ":" && curlyDepth === 0 && squareDepth === 0 && parenDepth === 0) return index;
+		index++;
+	}
+	return -1;
+}
+function normalizePropertyKey(rawKey) {
+	const trimmed = rawKey.trim();
+	if (trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith("\"") && trimmed.endsWith("\"")) return trimmed.slice(1, -1);
+	return trimmed;
+}
+function findRootNameLiteralRange(source) {
+	const objectStart = findConfigObjectStart(source);
+	if (objectStart < 0) return null;
+	for (const slice of getRootPropertySlices(source, objectStart)) {
+		const keyStart = skipWhitespaceAndComments(source, slice.start, slice.end);
+		const colonIndex = findTopLevelColon(source, keyStart, slice.end);
+		if (colonIndex < 0) continue;
+		if (normalizePropertyKey(source.slice(keyStart, colonIndex)) !== "name") continue;
+		const valueStart = skipWhitespaceAndComments(source, colonIndex + 1, slice.end);
+		const quote = source[valueStart];
+		if (quote !== "'" && quote !== "\"") throw new Error("The top-level `name` property must be a string literal to be updated automatically.");
+		return {
+			start: valueStart,
+			end: consumeQuotedLiteral(source, valueStart, slice.end),
+			quote
+		};
+	}
+	return null;
+}
+function quoteWorkerName(value, quote) {
+	return `${quote}${value.replace(/\\/g, "\\\\").replace(new RegExp(`\\${quote}`, "g"), `\\${quote}`)}${quote}`;
+}
+async function updateConfigName(configPath, newName) {
+	const fs = await import("node:fs/promises");
+	const source = await fs.readFile(configPath, "utf-8");
+	const literalRange = findRootNameLiteralRange(source);
+	if (!literalRange) throw new Error("Could not locate a top-level string literal `name` property in the selected devflare config.");
+	const magicString = new MagicString(source);
+	magicString.overwrite(literalRange.start, literalRange.end, quoteWorkerName(newName, literalRange.quote));
+	await fs.writeFile(configPath, magicString.toString(), "utf-8");
+}
+function collectReferenceHitsFromConfig(configPath, configLike, oldName, scope) {
+	if (!configLike?.bindings) return [];
+	const hits = [];
+	for (const [bindingName, bindingConfig] of Object.entries(configLike.bindings.services ?? {})) if (bindingConfig.service === oldName) hits.push({
+		configPath,
+		scope,
+		kind: "service",
+		bindingName
+	});
+	for (const [bindingName, bindingConfig] of Object.entries(configLike.bindings.durableObjects ?? {})) if (normalizeDOBinding(bindingConfig).scriptName === oldName) hits.push({
+		configPath,
+		scope,
+		kind: "durable-object",
+		bindingName
+	});
+	return hits;
+}
+function collectReferenceHits(loadedConfigs, oldName) {
+	const hits = [];
+	for (const record of loadedConfigs) {
+		hits.push(...collectReferenceHitsFromConfig(record.configPath, record.config, oldName, "root"));
+		for (const [envName, envConfig] of Object.entries(record.config.env ?? {})) hits.push(...collectReferenceHitsFromConfig(record.configPath, envConfig, oldName, `env.${envName}`));
+	}
+	return hits;
+}
+async function runWorkerCommand(parsed, logger, options) {
+	const cwd = options.cwd ?? process.cwd();
+	const theme = createCliTheme(parsed.options);
+	const subcommand = parsed.args[0];
+	const oldName = parsed.args[1]?.trim();
+	const newName = asOptionalString(parsed.options.to);
+	const explicitConfigPath = asOptionalString(parsed.options.config);
+	if (subcommand !== "rename") {
+		logger.error(`Unknown worker subcommand: ${subcommand ?? "<none>"}`);
+		logLine(logger, dim("Usage: devflare worker rename <old-name> --to <new-name> [--config <path>]", theme));
+		return { exitCode: 1 };
+	}
+	if (!oldName) {
+		logger.error("A current Worker name is required.");
+		logLine(logger, dim("Usage: devflare worker rename <old-name> --to <new-name> [--config <path>]", theme));
+		return { exitCode: 1 };
+	}
+	if (!newName) {
+		logger.error("The new Worker name must be provided with --to.");
+		return { exitCode: 1 };
+	}
+	if (oldName === newName) {
+		logger.error("The new Worker name must be different from the current name.");
+		return { exitCode: 1 };
+	}
+	logLine(logger);
+	logLine(logger, `${yellow("worker", theme)} ${dim("Renaming Worker identity", theme)}`);
+	logLine(logger, `${dim("from", theme)} ${whiteDim(oldName, theme)}`);
+	logLine(logger, `${dim("to", theme)} ${green(newName, theme)}`);
+	if (!await account.isAuthenticated()) {
+		logger.error("Not authenticated with Cloudflare");
+		logLine(logger, dim("Run `devflare login` first.", theme));
+		return { exitCode: 1 };
+	}
+	let remoteRenamed = false;
+	try {
+		const explicitResolvedConfigPath = explicitConfigPath ? await resolveConfigCandidatePath(resolve(cwd, explicitConfigPath)) : null;
+		if (explicitConfigPath && !explicitResolvedConfigPath) throw new Error(`${formatSupportedConfigFilenames()} not found for --config ${explicitConfigPath}.`);
+		const { target, localConfigAlreadyUpdated, allConfigs } = selectTargetConfig(await loadDiscoveredConfigs(cwd, explicitResolvedConfigPath ?? void 0), cwd, oldName, newName, explicitResolvedConfigPath ?? void 0);
+		const accountId = await resolveAccountId(parsed, target.config);
+		if (!accountId) {
+			logger.error("No Cloudflare account could be resolved for this config.");
+			logLine(logger, dim("Set accountId in devflare.config.ts, pass --account, or configure a default account.", theme));
+			return { exitCode: 1 };
+		}
+		logLine(logger, `${dim("config", theme)} ${whiteDim(formatPathForLog(cwd, target.configPath), theme)}`);
+		logLine(logger, `${dim("account", theme)} ${whiteDim(accountId, theme)}`);
+		logLine(logger);
+		const workers = await account.workers(accountId);
+		const hasOldWorker = workers.some((worker) => worker.name === oldName);
+		const hasNewWorker = workers.some((worker) => worker.name === newName);
+		if (hasOldWorker && hasNewWorker) {
+			logger.error(`Both \`${oldName}\` and \`${newName}\` already exist in Cloudflare.`);
+			logLine(logger, dim("Refusing to rename because the target Worker name is already taken.", theme));
+			return { exitCode: 1 };
+		}
+		if (!hasOldWorker && !hasNewWorker) {
+			logger.error(`Neither \`${oldName}\` nor \`${newName}\` exists in Cloudflare for account ${accountId}.`);
+			return { exitCode: 1 };
+		}
+		if (hasOldWorker && !hasNewWorker) {
+			await account.renameWorker(accountId, oldName, newName);
+			remoteRenamed = true;
+			logger.success(`Renamed remote Worker ${oldName} → ${newName}`);
+		} else logLine(logger, `${dim("remote", theme)} ${green(newName, theme)} ${dim("is already the active Worker name in Cloudflare", theme)}`);
+		if (!localConfigAlreadyUpdated) {
+			await updateConfigName(target.configPath, newName);
+			logger.success(`Updated ${formatPathForLog(cwd, target.configPath)}`);
+		} else logLine(logger, `${dim("config", theme)} ${green("already updated locally", theme)}`);
+		const referenceHits = collectReferenceHits(allConfigs, oldName);
+		if (referenceHits.length > 0) {
+			logger.warn(`Found ${referenceHits.length} local reference(s) that still use \`${oldName}\`.`);
+			for (const hit of referenceHits) logLine(logger, `  ${formatPathForLog(cwd, hit.configPath)} ${dim(`(${hit.scope})`, theme)} ${dim("—", theme)} ${hit.kind === "service" ? "service binding" : "durable object binding"} ${bold(hit.bindingName, theme)}`);
+		}
+		logLine(logger);
+		logLine(logger, `${yellow("preview urls", theme)} ${dim("Existing preview URLs and registry entries may continue using the old Worker name until you upload fresh previews for the renamed Worker.", theme)}`);
+		logLine(logger, dim("Future deploys and preview uploads from this config will target the new Worker name.", theme));
+		return { exitCode: 0 };
+	} catch (error) {
+		if (remoteRenamed) {
+			logger.warn("The remote Worker rename succeeded, but the local config update did not complete.");
+			logLine(logger, dim("Update devflare.config.ts manually so future deploys target the renamed Worker.", theme));
+		}
+		if (error instanceof Error) {
+			logger.error(error.message);
+			return { exitCode: 1 };
+		}
+		throw error;
+	}
+}
+//#endregion
+export { runWorkerCommand };