devflare 1.0.0-next.7 → 1.0.0-next.70

package/dist/_chunks/r2-presign-runtime-C75FkLMd.js

@@ -0,0 +1,291 @@
+import { x as normalizeWorkflowBinding } from "./schema-normalization-CTdiY17P.js";
+import { i as findFiles, r as DEFAULT_WORKFLOW_PATTERN } from "./glob-DRw9sbfF.js";
+import { t as bundleWorkerEntry } from "./worker-bundler-Isj5jiW6.js";
+import { join, relative, resolve } from "pathe";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+//#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
+//#region src/bridge/r2-presign-runtime.ts
+/**
+* Inline JS defining `__devflareR2PresignHandle(request, env, url)`, which
+* returns a `Response` when the request targets the local presign endpoint
+* and `null` otherwise. Enforces signature, expiry, method, content type and
+* size against the per-boot secret in `env.DEVFLARE_R2_PRESIGN_SECRET`, then
+* executes the object operation on the local R2 binding.
+*/
+const R2_PRESIGN_RUNTIME_JS = `
+const __devflareR2PresignPrefix = '/_devflare/r2/presigned/'
+
+const __devflareR2PresignCors = {
+	'Access-Control-Allow-Origin': '*',
+	'Access-Control-Allow-Methods': 'GET, HEAD, PUT, OPTIONS',
+	'Access-Control-Allow-Headers': 'Content-Type',
+	'Access-Control-Expose-Headers': 'ETag, Content-Type, Content-Length'
+}
+
+function __devflareR2PresignError(status, code, message) {
+	return new Response(JSON.stringify({ error: { code, message } }), {
+		status,
+		headers: { 'Content-Type': 'application/json', ...__devflareR2PresignCors }
+	})
+}
+
+async function __devflareR2PresignHmacHex(secret, message) {
+	const encoder = new TextEncoder()
+	const key = await crypto.subtle.importKey(
+		'raw',
+		encoder.encode(secret),
+		{ name: 'HMAC', hash: 'SHA-256' },
+		false,
+		['sign']
+	)
+	const signature = await crypto.subtle.sign('HMAC', key, encoder.encode(message))
+	return [...new Uint8Array(signature)].map((b) => b.toString(16).padStart(2, '0')).join('')
+}
+
+// Constant-time hex comparison (uses workerd's timingSafeEqual when present).
+function __devflareR2PresignEqual(expectedHex, actualHex) {
+	if (typeof actualHex !== 'string' || actualHex.length !== expectedHex.length) return false
+	const encoder = new TextEncoder()
+	const expected = encoder.encode(expectedHex)
+	const actual = encoder.encode(actualHex)
+	const subtle = crypto.subtle
+	if (subtle && typeof subtle.timingSafeEqual === 'function') {
+		return subtle.timingSafeEqual(expected, actual)
+	}
+	let diff = 0
+	for (let i = 0; i < expected.length; i++) diff |= expected[i] ^ actual[i]
+	return diff === 0
+}
+
+// MUST match buildLocalCanonicalString in src/runtime/r2-presign.ts.
+function __devflareR2PresignCanonical(method, binding, key, expires, contentType, contentLength, maxSize) {
+	return [
+		'devflare:r2-presign:v1',
+		method,
+		binding,
+		key,
+		expires,
+		contentType || '',
+		contentLength || '',
+		maxSize || ''
+	].join('\\n')
+}
+
+/**
+ * Handle a request to the local presigned R2 endpoint; returns null when the
+ * path does not match so gateways can fall through to their other routes.
+ */
+async function __devflareR2PresignHandle(request, env, url) {
+	if (!url.pathname.startsWith(__devflareR2PresignPrefix)) return null
+
+	if (request.method === 'OPTIONS') {
+		return new Response(null, {
+			status: 204,
+			headers: { ...__devflareR2PresignCors, 'Access-Control-Max-Age': '86400' }
+		})
+	}
+
+	const rest = url.pathname.slice(__devflareR2PresignPrefix.length)
+	const slashIndex = rest.indexOf('/')
+	if (slashIndex <= 0 || slashIndex === rest.length - 1) {
+		return __devflareR2PresignError(400, 'bad_request', 'Expected /_devflare/r2/presigned/<binding>/<key>.')
+	}
+	const binding = decodeURIComponent(rest.slice(0, slashIndex))
+	const key = rest
+		.slice(slashIndex + 1)
+		.split('/')
+		.map((segment) => decodeURIComponent(segment))
+		.join('/')
+
+	const secret = env.DEVFLARE_R2_PRESIGN_SECRET
+	if (typeof secret !== 'string' || secret.length === 0) {
+		return __devflareR2PresignError(
+			500,
+			'presign_unconfigured',
+			'DEVFLARE_R2_PRESIGN_SECRET is not configured on the devflare gateway. '
+				+ 'This endpoint is only served for configs with R2 bindings.'
+		)
+	}
+
+	const params = url.searchParams
+	const signedMethod = params.get('X-Devflare-Method')
+	const expires = params.get('X-Devflare-Expires')
+	const providedSignature = params.get('X-Devflare-Signature')
+	const signedContentType = params.get('X-Devflare-Content-Type')
+	const signedContentLength = params.get('X-Devflare-Content-Length')
+	const signedMaxSize = params.get('X-Devflare-Max-Size')
+
+	if (!signedMethod || !expires || !providedSignature) {
+		return __devflareR2PresignError(403, 'missing_parameters', 'Missing presign query parameters.')
+	}
+
+	const expectedSignature = await __devflareR2PresignHmacHex(
+		secret,
+		__devflareR2PresignCanonical(
+			signedMethod, binding, key, expires, signedContentType, signedContentLength, signedMaxSize
+		)
+	)
+	if (!__devflareR2PresignEqual(expectedSignature, providedSignature)) {
+		return __devflareR2PresignError(403, 'invalid_signature', 'Presigned URL signature mismatch.')
+	}
+
+	if (Math.floor(Date.now() / 1000) > Number(expires)) {
+		return __devflareR2PresignError(403, 'expired', 'Presigned URL has expired.')
+	}
+
+	const methodAllowed = signedMethod === 'GET'
+		? request.method === 'GET' || request.method === 'HEAD'
+		: request.method === signedMethod
+	if (!methodAllowed) {
+		return __devflareR2PresignError(
+			403,
+			'method_mismatch',
+			'URL was presigned for ' + signedMethod + ', got ' + request.method + '.'
+		)
+	}
+
+	const bucket = env[binding]
+	if (!bucket || typeof bucket.put !== 'function' || typeof bucket.head !== 'function') {
+		return __devflareR2PresignError(404, 'unknown_binding', 'R2 binding not found: ' + binding)
+	}
+
+	if (request.method === 'PUT') {
+		const sentContentType = request.headers.get('Content-Type')
+		if (signedContentType !== null && sentContentType !== signedContentType) {
+			return __devflareR2PresignError(
+				403,
+				'content_type_mismatch',
+				'URL was presigned for Content-Type "' + signedContentType + '", got "' + sentContentType + '".'
+			)
+		}
+
+		const body = await request.arrayBuffer()
+		if (signedContentLength !== null && body.byteLength !== Number(signedContentLength)) {
+			return __devflareR2PresignError(
+				403,
+				'content_length_mismatch',
+				'URL was presigned for exactly ' + signedContentLength + ' bytes, got ' + body.byteLength + '.'
+			)
+		}
+		if (signedMaxSize !== null && body.byteLength > Number(signedMaxSize)) {
+			return __devflareR2PresignError(
+				413,
+				'too_large',
+				'Body of ' + body.byteLength + ' bytes exceeds the presigned maximum of ' + signedMaxSize + '.'
+			)
+		}
+
+		const putContentType = sentContentType || signedContentType || undefined
+		const result = await bucket.put(key, body, {
+			...(putContentType && { httpMetadata: { contentType: putContentType } })
+		})
+		return new Response(null, {
+			status: 200,
+			headers: { ...__devflareR2PresignCors, ...(result?.httpEtag && { ETag: result.httpEtag }) }
+		})
+	}
+
+	// GET / HEAD
+	const objectHeaders = (object) => ({
+		...__devflareR2PresignCors,
+		'Content-Type': object.httpMetadata?.contentType || 'application/octet-stream',
+		'Content-Length': String(object.size),
+		...(object.httpEtag && { ETag: object.httpEtag })
+	})
+
+	if (request.method === 'HEAD') {
+		const object = await bucket.head(key)
+		if (!object) return __devflareR2PresignError(404, 'not_found', 'Object not found: ' + key)
+		return new Response(null, { status: 200, headers: objectHeaders(object) })
+	}
+
+	const object = await bucket.get(key)
+	if (!object) return __devflareR2PresignError(404, 'not_found', 'Object not found: ' + key)
+	return new Response(object.body, { status: 200, headers: objectHeaders(object) })
+}
+`;
+//#endregion
+export { bundleWorkflowEntrypointScript as n, R2_PRESIGN_RUNTIME_JS as t };

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-8jEHLVGg.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-D0NVzAFN.js";
+import { n as enableRemoteMode, r as getEffectiveRemoteModeStatus, t as disableRemoteMode } from "./remote-config-Bw6qIVM4.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 };

package/dist/_chunks/remote-config-Bw6qIVM4.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 };