devflare 1.0.0-next.5 → 1.0.0-next.51

package/dist/_chunks/local-workflow-entrypoints-8d_mXh8T.js

@@ -0,0 +1,90 @@
+import { x as normalizeWorkflowBinding } from "./schema-normalization-GjhTATHL.js";
+import { i as findFiles, r as DEFAULT_WORKFLOW_PATTERN } from "./glob-CmQOvunB.js";
+import { t as bundleWorkerEntry } from "./worker-bundler-dTTnYU3n.js";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, relative, resolve } from "pathe";
+//#region src/workflows/local-workflow-entrypoints.ts
+function findExportedClasses(code) {
+	const classes = [];
+	const classPattern = /export\s+class\s+(\w+)/g;
+	let match = classPattern.exec(code);
+	while (match !== null) {
+		classes.push(match[1]);
+		match = classPattern.exec(code);
+	}
+	return classes;
+}
+function toImportSpecifier(fromDir, filePath) {
+	const relativePath = relative(fromDir, filePath).replace(/\\/g, "/");
+	return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+async function discoverWorkflowClasses(config, configDir) {
+	const classToFilePath = /* @__PURE__ */ new Map();
+	const workflowPatternConfig = config.files?.workflows;
+	const workflowPattern = typeof workflowPatternConfig === "string" ? workflowPatternConfig : DEFAULT_WORKFLOW_PATTERN;
+	if (workflowPatternConfig === false) return classToFilePath;
+	const files = await findFiles(workflowPattern, { cwd: configDir });
+	for (const filePath of files) try {
+		const code = await readFile(filePath, "utf-8");
+		for (const className of findExportedClasses(code)) classToFilePath.set(className, filePath);
+	} catch {}
+	return classToFilePath;
+}
+async function resolveLocalWorkflowEntrypoints(config, configDir) {
+	const workflows = config.bindings?.workflows;
+	if (!workflows || Object.keys(workflows).length === 0) return [];
+	const classToFilePath = await discoverWorkflowClasses(config, configDir);
+	const entrypoints = [];
+	for (const [bindingName, binding] of Object.entries(workflows)) {
+		const normalized = normalizeWorkflowBinding(binding);
+		if (normalized.scriptName) continue;
+		const scriptPath = classToFilePath.get(normalized.className);
+		if (!scriptPath) throw new Error(`Workflow binding ${bindingName} (className: '${normalized.className}') not found.\nEither set files.workflows to match the workflow source file, or set scriptName when the workflow lives in another worker.`);
+		entrypoints.push({
+			bindingName,
+			className: normalized.className,
+			scriptPath
+		});
+	}
+	return entrypoints;
+}
+function buildWorkflowVirtualEntry(entrypoints, entryDir) {
+	const imports = entrypoints.map((entrypoint, index) => {
+		const importName = `__DevflareWorkflow${index}`;
+		const importPath = toImportSpecifier(entryDir, entrypoint.scriptPath);
+		return {
+			importName,
+			className: entrypoint.className,
+			line: `import { ${entrypoint.className} as ${importName} } from '${importPath}'`
+		};
+	});
+	const exports = imports.map((entrypoint) => {
+		return `export { ${entrypoint.importName} as ${entrypoint.className} }`;
+	});
+	return [
+		...imports.map((entrypoint) => entrypoint.line),
+		"",
+		...exports
+	].join("\n");
+}
+async function bundleWorkflowEntrypointScript(config, configDir, options = {}) {
+	const entrypoints = await resolveLocalWorkflowEntrypoints(config, configDir);
+	if (entrypoints.length === 0) return "";
+	const entryDir = resolve(configDir, ".devflare", "workflow-entrypoints");
+	const entryPath = join(entryDir, "__entry.ts");
+	const outFile = join(entryDir, "index.js");
+	await mkdir(entryDir, { recursive: true });
+	await writeFile(entryPath, buildWorkflowVirtualEntry(entrypoints, entryDir));
+	await bundleWorkerEntry({
+		cwd: configDir,
+		inputFile: entryPath,
+		outFile,
+		rolldownOptions: config.rolldown?.options,
+		sourcemap: config.rolldown?.sourcemap,
+		minify: config.rolldown?.minify,
+		logger: options.logger
+	});
+	return await readFile(outFile, "utf-8");
+}
+//#endregion
+export { bundleWorkflowEntrypointScript as t };

package/dist/_chunks/login-rVWUZOKC.js

@@ -0,0 +1,51 @@
+import { t as account } from "./cloudflare-BaloqI3H.js";
+import { d as green, f as logLine, g as yellow, h as whiteDim, o as dim, r as createCliTheme } from "./ui-BUoZApvE.js";
+import { n as getConfiguredAccountId } from "./command-utils-_bGRraDR.js";
+import { t as getDependencies } from "./dependencies-C2oxFjU_.js";
+//#region src/cli/commands/login.ts
+async function logResolvedAccount(cwd, logger, theme) {
+	try {
+		const primaryAccount = await account.getPrimaryAccount();
+		if (primaryAccount) {
+			logLine(logger, `${dim("Primary account:", theme)} ${green(primaryAccount.name, theme)} ${whiteDim(`(${primaryAccount.id})`, theme)}`);
+			return;
+		}
+	} catch {}
+	const configuredAccountId = await getConfiguredAccountId(cwd);
+	if (!configuredAccountId) {
+		logLine(logger, dim("Run `devflare account` to inspect available accounts.", theme));
+		return;
+	}
+	const configuredAccount = await account.getAccountById(configuredAccountId);
+	if (configuredAccount) {
+		logLine(logger, `${dim("Configured account:", theme)} ${green(configuredAccount.name, theme)} ${whiteDim(`(${configuredAccount.id})`, theme)}`);
+		return;
+	}
+	logLine(logger, `${dim("Configured account ID:", theme)} ${whiteDim(configuredAccountId, theme)}`);
+	logLine(logger, dim("Run `devflare account --account <id>` to inspect the configured account.", theme));
+}
+async function runLoginCommand(parsed, logger, options) {
+	const force = parsed.options.force === true;
+	const cwd = options.cwd ?? process.cwd();
+	const theme = createCliTheme(parsed.options);
+	if (!force && await account.isAuthenticated()) {
+		logger.success("Already authenticated with Cloudflare");
+		await logResolvedAccount(cwd, logger, theme);
+		logLine(logger, dim("Use `devflare login --force` to open Wrangler login again.", theme));
+		return { exitCode: 0 };
+	}
+	logLine(logger);
+	logLine(logger, `${yellow("login", theme)} ${dim("Opening Wrangler login…", theme)}`);
+	if ((await (await getDependencies()).exec.exec("bunx", ["wrangler", "login"], {
+		cwd,
+		stdio: "inherit"
+	})).exitCode !== 0) {
+		logger.error("Wrangler login failed");
+		return { exitCode: 1 };
+	}
+	logger.success("Authenticated with Cloudflare");
+	await logResolvedAccount(cwd, logger, theme);
+	return { exitCode: 0 };
+}
+//#endregion
+export { runLoginCommand };

package/dist/_chunks/package-metadata-DjHBLB-z.js

@@ -0,0 +1,39 @@
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "pathe";
+import { fileURLToPath } from "node:url";
+//#region src/cli/package-metadata.ts
+let packageMetadataPromise = null;
+async function loadPackageMetadata() {
+	let currentDir = dirname(fileURLToPath(import.meta.url));
+	while (true) {
+		const packageJsonPath = resolve(currentDir, "package.json");
+		try {
+			const packageJson = await readFile(packageJsonPath, "utf8");
+			const metadata = JSON.parse(packageJson);
+			if (metadata.name === "devflare") return metadata;
+		} catch {}
+		const parentDir = dirname(currentDir);
+		if (parentDir === currentDir) throw new Error("Could not resolve the devflare package.json file");
+		currentDir = parentDir;
+	}
+}
+async function getPackageMetadata() {
+	if (!packageMetadataPromise) packageMetadataPromise = loadPackageMetadata();
+	return packageMetadataPromise;
+}
+async function getPackageVersion() {
+	return (await getPackageMetadata()).version ?? "0.0.0";
+}
+async function getInitDependencyVersions() {
+	const metadata = await getPackageMetadata();
+	const dependencies = metadata.dependencies ?? {};
+	const devDependencies = metadata.devDependencies ?? {};
+	return {
+		devflare: `^${metadata.version ?? "0.0.0"}`,
+		typescript: dependencies.typescript ?? devDependencies.typescript ?? "^5.7.0",
+		wrangler: dependencies.wrangler ?? devDependencies.wrangler ?? "^4.85.0",
+		workersTypes: devDependencies["@cloudflare/workers-types"] ?? "^4.20250109.0"
+	};
+}
+//#endregion
+export { getPackageVersion as n, getInitDependencyVersions as t };

package/dist/_chunks/preferences-BKp_7XJx.js

@@ -0,0 +1,241 @@
+import { a as apiGetAll, d as kvGet, f as kvPut, i as apiGet, s as apiPost, u as kvDelete } from "./api-TzdliH-6.js";
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+//#region src/cloudflare/account-core.ts
+async function getAccounts(options) {
+	return (await apiGetAll("/accounts", options)).map((account) => ({
+		id: account.id,
+		name: account.name,
+		type: account.type,
+		createdOn: account.created_on ? new Date(account.created_on) : void 0
+	}));
+}
+async function getPrimaryAccount(options) {
+	return (await getAccounts(options))[0] ?? null;
+}
+async function getAccountById(accountId, options) {
+	try {
+		const account = await apiGet(`/accounts/${accountId}`, options);
+		return {
+			id: account.id,
+			name: account.name,
+			type: account.type,
+			createdOn: account.created_on ? new Date(account.created_on) : void 0
+		};
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/cloudflare/kv-namespace.ts
+const DEVFLARE_KV_NAMESPACE_TITLE = "devflare-usage";
+async function getOrCreateNamedKVNamespace(accountId, title = DEVFLARE_KV_NAMESPACE_TITLE, options) {
+	const existing = (await apiGetAll(`/accounts/${accountId}/storage/kv/namespaces`, options)).find((namespace) => namespace.title === title);
+	if (existing) return existing.id;
+	return (await apiPost(`/accounts/${accountId}/storage/kv/namespaces`, { title }, options)).id;
+}
+//#endregion
+//#region src/cloudflare/preferences.ts
+const GLOBAL_ACCOUNT_KEY = "settings:defaultAccountId";
+const LOCAL_CACHE_DIR = ".devflare";
+const LOCAL_CACHE_FILE = "preferences.json";
+/**
+* Write a file atomically by writing to a temp sibling and renaming into place.
+* Prevents corruption if the process is killed mid-write.
+*
+* @internal exported for tests only
+*/
+function writeFileAtomic(path, contents) {
+	const tmpPath = path + ".tmp-" + process.pid + "-" + Date.now();
+	writeFileSync(tmpPath, contents, "utf-8");
+	try {
+		renameSync(tmpPath, path);
+	} catch (error) {
+		try {
+			unlinkSync(tmpPath);
+		} catch {}
+		throw error;
+	}
+}
+/**
+* Get the path to the local preferences file
+*/
+function getLocalPreferencesPath() {
+	return join(homedir(), LOCAL_CACHE_DIR, LOCAL_CACHE_FILE);
+}
+/**
+* Read local preferences from disk
+*/
+function readLocalPreferences() {
+	const path = getLocalPreferencesPath();
+	if (!existsSync(path)) return {};
+	try {
+		const content = readFileSync(path, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return {};
+	}
+}
+/**
+* Write local preferences to disk
+*/
+function writeLocalPreferences(prefs) {
+	const path = getLocalPreferencesPath();
+	const dir = join(homedir(), LOCAL_CACHE_DIR);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	writeFileAtomic(path, JSON.stringify(prefs, null, "	"));
+}
+/**
+* Find the nearest package.json (searching upward from cwd)
+*/
+function findPackageJsonPath(startDir) {
+	let dir = startDir ?? process.cwd();
+	while (dir !== join(dir, "..")) {
+		const pkgPath = join(dir, "package.json");
+		if (existsSync(pkgPath)) return pkgPath;
+		dir = join(dir, "..");
+	}
+	return null;
+}
+/**
+* Read package.json from a path
+*/
+function readPackageJson(path) {
+	try {
+		const content = readFileSync(path, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return null;
+	}
+}
+/**
+* Write package.json to a path
+*/
+function writePackageJson(path, pkg) {
+	writeFileAtomic(path, JSON.stringify(pkg, null, "	") + "\n");
+}
+/**
+* Get workspace account ID from nearest package.json
+*/
+function getWorkspaceAccountId() {
+	const pkgPath = findPackageJsonPath();
+	if (!pkgPath) return null;
+	return readPackageJson(pkgPath)?.devflare?.accountId ?? null;
+}
+/**
+* Set workspace account ID in nearest package.json
+* Creates package.json if it doesn't exist
+*/
+function setWorkspaceAccountId(accountId) {
+	let pkgPath = findPackageJsonPath();
+	let pkg;
+	if (pkgPath) pkg = readPackageJson(pkgPath) ?? {};
+	else {
+		pkgPath = join(process.cwd(), "package.json");
+		pkg = {
+			name: "workspace",
+			private: true
+		};
+	}
+	if (!pkg.devflare) pkg.devflare = {};
+	pkg.devflare.accountId = accountId;
+	writePackageJson(pkgPath, pkg);
+	return pkgPath;
+}
+/**
+* Find or create the devflare-managed KV namespace
+* (Reuses the same namespace as usage tracking)
+*/
+async function getOrCreatePreferencesNamespace(accountId) {
+	return getOrCreateNamedKVNamespace(accountId, DEVFLARE_KV_NAMESPACE_TITLE);
+}
+/**
+* Get the global default account ID
+*
+* Priority:
+* 1. Local cache (fast, no network)
+* 2. Cloud KV (if local cache is missing)
+*
+* Returns null if no default is set
+*/
+async function getGlobalDefaultAccountId(fallbackAccountId) {
+	const local = readLocalPreferences();
+	if (local.defaultAccountId) return local.defaultAccountId;
+	try {
+		const value = await kvGet(fallbackAccountId, await getOrCreatePreferencesNamespace(fallbackAccountId), GLOBAL_ACCOUNT_KEY);
+		if (value) {
+			writeLocalPreferences({
+				...local,
+				defaultAccountId: value,
+				lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			return value;
+		}
+	} catch (error) {
+		console.debug("[devflare preferences] cloud KV sync failed:", error instanceof Error ? error.message : String(error));
+	}
+	return null;
+}
+/**
+* Set the global default account ID
+* Saves to both local cache and cloud KV
+*
+* @param accountId - The account ID to set as default
+* @param anyAccountId - Any account ID to use for accessing KV (can be the same)
+*/
+async function setGlobalDefaultAccountId(accountId, anyAccountId) {
+	const kvAccountId = anyAccountId ?? accountId;
+	writeLocalPreferences({
+		...readLocalPreferences(),
+		defaultAccountId: accountId,
+		lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	try {
+		await kvPut(kvAccountId, await getOrCreatePreferencesNamespace(kvAccountId), GLOBAL_ACCOUNT_KEY, accountId);
+	} catch (error) {
+		console.debug("[devflare preferences] cloud KV sync failed:", error instanceof Error ? error.message : String(error));
+	}
+}
+/**
+* Get the effective account ID to use
+*
+* Priority:
+* 1. Workspace (package.json) - highest priority
+* 2. Global default (local cache + cloud KV)
+* 3. Primary account (first account in list)
+*
+* @param primaryAccountId - The primary account ID to use as fallback
+*/
+async function getEffectiveAccountId(primaryAccountId) {
+	const workspaceId = getWorkspaceAccountId();
+	if (workspaceId) return {
+		accountId: workspaceId,
+		source: "workspace"
+	};
+	const globalId = await getGlobalDefaultAccountId(primaryAccountId);
+	if (globalId) return {
+		accountId: globalId,
+		source: "global"
+	};
+	return {
+		accountId: primaryAccountId,
+		source: "primary"
+	};
+}
+/**
+* Clear the global default account ID (both local and cloud)
+*/
+async function clearGlobalDefaultAccountId(anyAccountId) {
+	const local = readLocalPreferences();
+	delete local.defaultAccountId;
+	local.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+	writeLocalPreferences(local);
+	try {
+		await kvDelete(anyAccountId, await getOrCreatePreferencesNamespace(anyAccountId), GLOBAL_ACCOUNT_KEY);
+	} catch (error) {
+		console.debug("[devflare preferences] cloud KV sync failed:", error instanceof Error ? error.message : String(error));
+	}
+}
+//#endregion
+export { setGlobalDefaultAccountId as a, getOrCreateNamedKVNamespace as c, getPrimaryAccount as d, getWorkspaceAccountId as i, getAccountById as l, getEffectiveAccountId as n, setWorkspaceAccountId as o, getGlobalDefaultAccountId as r, DEVFLARE_KV_NAMESPACE_TITLE as s, clearGlobalDefaultAccountId as t, getAccounts as u };