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

package/dist/_chunks/remote-config-D39BY9ji.js

@@ -0,0 +1,132 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+//#region src/cloudflare/remote-config.ts
+/** Minimum duration in minutes */
+const MIN_MINUTES = 1;
+/** Maximum duration in minutes (24 hours) */
+const MAX_MINUTES = 1440;
+function getConfigDir() {
+	return join(homedir(), ".devflare");
+}
+function getConfigPath() {
+	return join(getConfigDir(), "remote.json");
+}
+function readConfig() {
+	const path = getConfigPath();
+	if (!existsSync(path)) return null;
+	try {
+		const content = readFileSync(path, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return null;
+	}
+}
+function writeConfig(config) {
+	const dir = getConfigDir();
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	writeFileSync(getConfigPath(), JSON.stringify(config, null, "	"));
+}
+function deleteConfig() {
+	const path = getConfigPath();
+	if (existsSync(path)) try {
+		unlinkSync(path);
+	} catch {}
+}
+/**
+* Enable remote mode for a given duration.
+* @param minutes Duration in minutes (default: 30, clamped to 1-1440)
+* @returns The validated minutes value actually used
+*/
+function enableRemoteMode(minutes = 30) {
+	const validMinutes = Math.max(MIN_MINUTES, Math.min(MAX_MINUTES, Math.floor(minutes) || 30));
+	const now = Date.now();
+	writeConfig({
+		enabledAt: now,
+		expiresAt: now + validMinutes * 60 * 1e3,
+		durationMinutes: validMinutes
+	});
+	return validMinutes;
+}
+/**
+* Disable remote mode immediately.
+*/
+function disableRemoteMode() {
+	deleteConfig();
+}
+/**
+* Get the current remote mode status from stored config.
+* Note: Use getEffectiveRemoteModeStatus() to also include env var override.
+* @returns Status object with isEnabled, remainingMinutes, and expiresAt
+*/
+function getRemoteModeStatus() {
+	const config = readConfig();
+	if (!config) return {
+		isEnabled: false,
+		remainingMinutes: 0,
+		expiresAt: null
+	};
+	const now = Date.now();
+	if (now >= config.expiresAt) {
+		deleteConfig();
+		return {
+			isEnabled: false,
+			remainingMinutes: 0,
+			expiresAt: null
+		};
+	}
+	const remainingMs = config.expiresAt - now;
+	return {
+		isEnabled: true,
+		remainingMinutes: Math.ceil(remainingMs / 6e4),
+		expiresAt: new Date(config.expiresAt)
+	};
+}
+/**
+* Get the effective remote mode status including env var override.
+* @returns Status object with isActive, source, and config details
+*/
+function getEffectiveRemoteModeStatus() {
+	const envValue = process.env.DEVFLARE_REMOTE ?? "";
+	if ([
+		"1",
+		"true",
+		"yes"
+	].includes(envValue.toLowerCase())) return {
+		isActive: true,
+		source: "env",
+		remainingMinutes: Number.POSITIVE_INFINITY,
+		expiresAt: null,
+		envVarSet: true
+	};
+	const status = getRemoteModeStatus();
+	if (status.isEnabled) return {
+		isActive: true,
+		source: "config",
+		remainingMinutes: status.remainingMinutes,
+		expiresAt: status.expiresAt,
+		envVarSet: false
+	};
+	return {
+		isActive: false,
+		source: "none",
+		remainingMinutes: 0,
+		expiresAt: null,
+		envVarSet: false
+	};
+}
+/**
+* Check if remote mode is currently enabled.
+* Checks both env var (DEVFLARE_REMOTE=1) and stored config.
+*/
+function isRemoteModeActive() {
+	const envValue = process.env.DEVFLARE_REMOTE ?? "";
+	if ([
+		"1",
+		"true",
+		"yes"
+	].includes(envValue.toLowerCase())) return true;
+	return getRemoteModeStatus().isEnabled;
+}
+//#endregion
+export { isRemoteModeActive as a, getRemoteModeStatus as i, enableRemoteMode as n, getEffectiveRemoteModeStatus as r, disableRemoteMode as t };

package/dist/_chunks/resolve-package-qizBfCIm.js

@@ -0,0 +1,152 @@
+import { a as findFilesSync, i as findFiles, n as DEFAULT_ENTRYPOINT_PATTERN } from "./glob-CmQOvunB.js";
+import { createRequire } from "node:module";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, resolve } from "pathe";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { readFileSync as readFileSync$1 } from "fs";
+//#region src/utils/entrypoint-discovery.ts
+/**
+* Regex pattern to find WorkerEntrypoint class exports
+* Matches: export class ClassName extends WorkerEntrypoint
+*/
+const ENTRYPOINT_CLASS_PATTERN = /export\s+class\s+(\w+)\s+extends\s+WorkerEntrypoint/g;
+/**
+* Find WorkerEntrypoint classes in source code
+* @param code - Source code to search
+* @returns Array of class names found
+*/
+function findEntrypointClasses(code) {
+	const classes = [];
+	ENTRYPOINT_CLASS_PATTERN.lastIndex = 0;
+	let match = ENTRYPOINT_CLASS_PATTERN.exec(code);
+	while (match !== null) {
+		classes.push(match[1]);
+		match = ENTRYPOINT_CLASS_PATTERN.exec(code);
+	}
+	return classes;
+}
+/**
+* Discover entrypoint classes from a glob pattern synchronously.
+* Respects `.gitignore` automatically.
+*
+* @param cwd - Working directory for glob resolution
+* @param pattern - Glob pattern for entrypoint files (default: recursive `ep.*.{ts,js}` matching)
+* @returns Array of discovered entrypoints
+*/
+function discoverEntrypointsSync(cwd, pattern = DEFAULT_ENTRYPOINT_PATTERN) {
+	const discovered = [];
+	try {
+		const files = findFilesSync(pattern, { cwd });
+		for (const file of files) try {
+			const classNames = findEntrypointClasses(readFileSync$1(file, "utf-8"));
+			for (const className of classNames) discovered.push({
+				className,
+				filePath: file
+			});
+		} catch {}
+	} catch {}
+	return discovered;
+}
+/**
+* Discover entrypoint classes from ep.*.ts files using glob pattern (async).
+* Respects .gitignore automatically.
+*
+* @param cwd - Working directory for glob
+* @param pattern - Glob pattern for ep.*.ts files (default: **​/ep.*.{ts,js})
+* @returns Array of discovered entrypoints
+*/
+async function discoverEntrypointsAsync(cwd, pattern = DEFAULT_ENTRYPOINT_PATTERN) {
+	const fs = await import("node:fs/promises");
+	const discovered = [];
+	const files = await findFiles(pattern, { cwd });
+	for (const filePath of files) try {
+		const classNames = findEntrypointClasses(await fs.readFile(filePath, "utf-8"));
+		for (const className of classNames) discovered.push({
+			className,
+			filePath
+		});
+	} catch {}
+	return discovered;
+}
+//#endregion
+//#region src/utils/resolve-package.ts
+const NOT_FOUND_CODES = new Set([
+	"MODULE_NOT_FOUND",
+	"ERR_MODULE_NOT_FOUND",
+	"ERR_PACKAGE_PATH_NOT_EXPORTED"
+]);
+function isNotFoundError(error) {
+	if (!error || typeof error !== "object") return false;
+	const code = error.code;
+	return typeof code === "string" && NOT_FOUND_CODES.has(code);
+}
+/**
+* Find a package's own `package.json` by walking `node_modules` up the tree,
+* exactly like Node's directory resolution — and crucially WITHOUT consulting
+* the package's `exports` map (a package need not expose `./package.json`).
+*/
+function findPackageJsonByWalk(packageName, fromDir) {
+	let dir = resolve(fromDir);
+	while (true) {
+		const candidate = resolve(dir, "node_modules", packageName, "package.json");
+		if (existsSync(candidate)) return realpathSync(candidate);
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+/**
+* Resolve `specifier` from `fromDir` using ESM-first resolution.
+*
+* Chain:
+*   1. `import.meta.resolve` (Bun exposes this synchronously for ESM packages)
+*   2. `createRequire(fromDir).resolve` (CommonJS fallback)
+*
+* Only swallows MODULE_NOT_FOUND / ERR_MODULE_NOT_FOUND. Any other error
+* (syntax, permission, etc.) is re-thrown.
+*/
+function resolveSpecifier(specifier, fromDir) {
+	const fromFileUrl = pathToFileURL(resolve(fromDir, "package.json")).href;
+	const importMetaResolve = import.meta.resolve;
+	if (typeof importMetaResolve === "function") try {
+		const resolved = importMetaResolve(specifier, fromFileUrl);
+		if (typeof resolved === "string") return resolved.startsWith("file:") ? fileURLToPath(resolved) : resolved;
+	} catch (error) {
+		if (!isNotFoundError(error)) throw error;
+	}
+	try {
+		return createRequire(fromFileUrl).resolve(specifier);
+	} catch (error) {
+		if (isNotFoundError(error)) return null;
+		throw error;
+	}
+}
+/**
+* Resolve a package specifier to a filesystem path
+* Handles workspace packages like '@devflare/case11-do-shared/devflare.config'
+*
+* @param specifier - Package specifier (e.g., '@scope/pkg/path' or './relative/path')
+* @param fromDir - Directory to resolve relative paths from
+* @returns Resolved filesystem path
+*/
+function resolvePackageSpecifier(specifier, fromDir) {
+	if (specifier.startsWith(".") || specifier.startsWith("/") || /^[A-Za-z]:/.test(specifier)) return resolve(fromDir, specifier);
+	const parts = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+	const subpath = specifier.startsWith("@") ? specifier.split("/").slice(2).join("/") : specifier.split("/").slice(1).join("/");
+	const pkgJsonPath = findPackageJsonByWalk(parts, fromDir) ?? resolveSpecifier(`${parts}/package.json`, fromDir);
+	if (!pkgJsonPath) return resolve(fromDir, specifier);
+	const pkgDir = dirname(pkgJsonPath);
+	if (subpath) {
+		const exportPath = JSON.parse(readFileSync(pkgJsonPath, "utf-8")).exports?.[`./${subpath}`];
+		if (exportPath) return resolve(pkgDir, typeof exportPath === "string" ? exportPath : exportPath.default || exportPath.import);
+		const directPath = resolve(pkgDir, `${subpath}.ts`);
+		if (existsSync(directPath)) return directPath;
+		const withExt = resolve(pkgDir, subpath);
+		if (existsSync(withExt)) return withExt;
+		if (existsSync(`${withExt}.ts`)) return `${withExt}.ts`;
+		if (existsSync(`${withExt}.js`)) return `${withExt}.js`;
+	}
+	return pkgDir;
+}
+//#endregion
+export { discoverEntrypointsAsync as n, discoverEntrypointsSync as r, resolvePackageSpecifier as t };

package/dist/_chunks/rolldown-runtime-CvQ6eiug.js

@@ -0,0 +1,14 @@
+import "node:module";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };