devflare 1.0.0-next.14 → 1.0.0-next.16

package/dist/index-0w826dsr.js

@@ -0,0 +1,379 @@
+// src/cloudflare/auth.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readFileSync, existsSync } from "node:fs";
+import { execSync } from "node:child_process";
+var WRANGLER_CONFIG_FILE = "config/default.toml";
+var EXPIRY_BUFFER_MS = 5 * 60 * 1000;
+var cachedToken = null;
+var cacheExpiresAt = 0;
+function invalidateToken() {
+  cachedToken = null;
+  cacheExpiresAt = 0;
+}
+function getWranglerConfigPaths() {
+  const paths = [];
+  if (process.platform === "win32" && process.env.APPDATA) {
+    paths.push(join(process.env.APPDATA, "xdg.config", ".wrangler", WRANGLER_CONFIG_FILE));
+  }
+  if (process.env.XDG_CONFIG_HOME) {
+    paths.push(join(process.env.XDG_CONFIG_HOME, ".wrangler", WRANGLER_CONFIG_FILE));
+  }
+  paths.push(join(homedir(), ".wrangler", WRANGLER_CONFIG_FILE));
+  return paths;
+}
+function getWranglerConfigPath() {
+  const paths = getWranglerConfigPaths();
+  for (const path of paths) {
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  return null;
+}
+function hasWranglerConfig() {
+  return getWranglerConfigPath() !== null;
+}
+function parseSimpleToml(content) {
+  const result = {};
+  const lines = content.split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || trimmed === "")
+      continue;
+    if (trimmed.startsWith("["))
+      continue;
+    const match = trimmed.match(/^(\w+)\s*=\s*["'](.*)["']$/);
+    if (match) {
+      result[match[1]] = match[2];
+    }
+  }
+  return result;
+}
+function readWranglerConfig() {
+  const configPath = getWranglerConfigPath();
+  if (!configPath || !existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const config = parseSimpleToml(content);
+    const token = config.oauth_token;
+    const expirationTime = config.expiration_time;
+    if (token && expirationTime) {
+      return {
+        token,
+        expiresAt: new Date(expirationTime)
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function getWranglerAuth() {
+  const config = readWranglerConfig();
+  if (!config)
+    return null;
+  const configPath = getWranglerConfigPath();
+  if (!configPath)
+    return null;
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const parsed = parseSimpleToml(content);
+    return {
+      oauthToken: parsed.oauth_token,
+      refreshToken: parsed.refresh_token,
+      expiresAt: config.expiresAt
+    };
+  } catch {
+    return null;
+  }
+}
+function refreshWranglerToken() {
+  try {
+    const result = execSync("bunx wrangler auth token", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 15000
+    });
+    const lines = result.trim().split(/\r?\n/).filter((l) => l.trim().length > 0);
+    const token = lines[lines.length - 1]?.trim();
+    if (token && token.length >= 20 && !token.includes("wrangler") && !token.includes("⛅")) {
+      return token;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function getApiToken(forceRefresh = false) {
+  if (!forceRefresh && cachedToken && Date.now() < cacheExpiresAt) {
+    return cachedToken;
+  }
+  const envToken = process.env.CLOUDFLARE_API_TOKEN;
+  if (envToken) {
+    return envToken;
+  }
+  if (!forceRefresh) {
+    const config = readWranglerConfig();
+    if (config) {
+      const now = Date.now();
+      const expiresAt = config.expiresAt.getTime();
+      if (now < expiresAt - EXPIRY_BUFFER_MS) {
+        cachedToken = config.token;
+        cacheExpiresAt = expiresAt - EXPIRY_BUFFER_MS;
+        return config.token;
+      }
+    }
+  }
+  const refreshedToken = refreshWranglerToken();
+  if (refreshedToken) {
+    cachedToken = refreshedToken;
+    cacheExpiresAt = Date.now() + EXPIRY_BUFFER_MS;
+    return refreshedToken;
+  }
+  return null;
+}
+async function isAuthenticated() {
+  const token = await getApiToken();
+  return token !== null;
+}
+
+// src/cloudflare/api.ts
+var API_BASE = "https://api.cloudflare.com/client/v4";
+var DEFAULT_TIMEOUT = 1e4;
+var hasRetriedWithFreshToken = false;
+async function fetchWithTimeout(url, init, timeoutMs) {
+  const controller = new AbortController;
+  const abortTimeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  let rejectTimeoutId = null;
+  const timeoutPromise = new Promise((_, reject) => {
+    rejectTimeoutId = setTimeout(() => reject(new Error(`Request timed out after ${timeoutMs}ms`)), timeoutMs);
+  });
+  try {
+    const response = await Promise.race([
+      fetch(url, { ...init, signal: controller.signal }),
+      timeoutPromise
+    ]);
+    return response;
+  } finally {
+    clearTimeout(abortTimeoutId);
+    if (rejectTimeoutId) {
+      clearTimeout(rejectTimeoutId);
+    }
+  }
+}
+
+class CloudflareAPIError extends Error {
+  code;
+  errors;
+  constructor(message, code, errors) {
+    super(message);
+    this.code = code;
+    this.errors = errors;
+    this.name = "CloudflareAPIError";
+  }
+}
+
+class AuthenticationError extends Error {
+  constructor(message = "Not authenticated. Run: devflare login") {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+}
+async function createHeaders(options, forceRefresh = false) {
+  const token = options?.token ?? await getApiToken(forceRefresh);
+  if (!token) {
+    throw new AuthenticationError;
+  }
+  return new Headers({
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json"
+  });
+}
+function isAuthError(response, data) {
+  if (response.status === 401)
+    return true;
+  if (!data.success && data.errors?.some((e) => e.code === 1e4 || e.message?.toLowerCase().includes("authentication") || e.message?.toLowerCase().includes("token"))) {
+    return true;
+  }
+  return false;
+}
+async function requestCloudflareJson(path, request, options) {
+  const makeRequest = async (forceRefresh) => {
+    const headers = await createHeaders(options, forceRefresh);
+    const response = await fetchWithTimeout(`${API_BASE}${path}`, {
+      method: request.method,
+      headers,
+      ...request.body !== undefined ? { body: JSON.stringify(request.body) } : {}
+    }, options?.timeout ?? DEFAULT_TIMEOUT);
+    const data = await response.json();
+    return {
+      response,
+      data
+    };
+  };
+  let result = await makeRequest(false);
+  if (request.allowAuthRetry === true && isAuthError(result.response, result.data) && !hasRetriedWithFreshToken && !options?.token) {
+    hasRetriedWithFreshToken = true;
+    invalidateToken();
+    try {
+      result = await makeRequest(true);
+    } finally {
+      hasRetriedWithFreshToken = false;
+    }
+  }
+  return result;
+}
+async function requestCloudflareResult(path, request, options) {
+  const { response, data } = await requestCloudflareJson(path, request, options);
+  return unwrapCloudflareResult(response, data);
+}
+function unwrapCloudflareResult(response, data, fallbackMessage = "API request failed") {
+  if (!data.success) {
+    throw new CloudflareAPIError(data.errors[0]?.message || fallbackMessage, response.status, data.errors);
+  }
+  return data.result;
+}
+async function throwCloudflareResponseError(response, fallbackMessage) {
+  try {
+    const errorData = await response.json();
+    throw new CloudflareAPIError(errorData.errors[0]?.message || fallbackMessage, response.status, errorData.errors);
+  } catch (error) {
+    if (error instanceof CloudflareAPIError) {
+      throw error;
+    }
+    throw new CloudflareAPIError(fallbackMessage, response.status, []);
+  }
+}
+async function apiGet(path, options) {
+  return requestCloudflareResult(path, {
+    method: "GET",
+    allowAuthRetry: true
+  }, options);
+}
+async function apiPost(path, body, options) {
+  return requestCloudflareResult(path, {
+    method: "POST",
+    body
+  }, options);
+}
+async function apiPut(path, body, options) {
+  return requestCloudflareResult(path, {
+    method: "PUT",
+    body
+  }, options);
+}
+async function apiPatch(path, body, options) {
+  return requestCloudflareResult(path, {
+    method: "PATCH",
+    body
+  }, options);
+}
+async function apiDelete(path, options) {
+  return requestCloudflareResult(path, {
+    method: "DELETE"
+  }, options);
+}
+async function apiGetAll(path, options) {
+  const results = [];
+  let page = 1;
+  let cursor;
+  const perPage = 50;
+  const maxPages = 100;
+  const seenCursors = new Set;
+  const extractPaginatedItems = (result) => {
+    if (Array.isArray(result)) {
+      return result;
+    }
+    if (!result || typeof result !== "object") {
+      throw new Error("Expected paginated Cloudflare API result to be an array or an object containing an array.");
+    }
+    const arrayEntries = Object.entries(result).filter(([, value]) => Array.isArray(value));
+    if (arrayEntries.length !== 1) {
+      throw new Error("Expected paginated Cloudflare API result object to contain exactly one array property.");
+    }
+    return arrayEntries[0][1];
+  };
+  while (page <= maxPages) {
+    const separator = path.includes("?") ? "&" : "?";
+    const pagedPath = cursor ? `${path}${separator}cursor=${encodeURIComponent(cursor)}&per_page=${perPage}` : `${path}${separator}page=${page}&per_page=${perPage}`;
+    const { response, data } = await requestCloudflareJson(pagedPath, {
+      method: "GET",
+      allowAuthRetry: true
+    }, options);
+    unwrapCloudflareResult(response, data);
+    const pageResults = extractPaginatedItems(data.result);
+    results.push(...pageResults);
+    if (!data.result_info) {
+      break;
+    }
+    if (pageResults.length === 0) {
+      break;
+    }
+    const nextCursor = data.result_info.cursor?.trim();
+    if (nextCursor) {
+      if (seenCursors.has(nextCursor)) {
+        break;
+      }
+      seenCursors.add(nextCursor);
+      cursor = nextCursor;
+      continue;
+    }
+    if (cursor) {
+      break;
+    }
+    if (data.result_info.total_count !== undefined) {
+      if (results.length >= data.result_info.total_count) {
+        break;
+      }
+    }
+    if (data.result_info.total_pages !== undefined) {
+      if (page >= data.result_info.total_pages) {
+        break;
+      }
+    }
+    page++;
+  }
+  return results;
+}
+async function requestKVValue(accountId, namespaceId, key, request, options) {
+  const token = options?.token ?? await getApiToken();
+  if (!token)
+    throw new AuthenticationError;
+  const encodedKey = encodeURIComponent(key);
+  const url = `${API_BASE}/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${encodedKey}`;
+  return fetchWithTimeout(url, {
+    method: request.method,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      ...request.method === "PUT" ? { "Content-Type": "text/plain" } : {}
+    },
+    ...request.method === "PUT" ? { body: request.value } : {}
+  }, options?.timeout ?? DEFAULT_TIMEOUT);
+}
+async function kvGet(accountId, namespaceId, key, options) {
+  const response = await requestKVValue(accountId, namespaceId, key, {
+    method: "GET"
+  }, options);
+  if (response.status === 404) {
+    return null;
+  }
+  if (!response.ok) {
+    await throwCloudflareResponseError(response, "KV read failed");
+  }
+  return response.text();
+}
+async function kvPut(accountId, namespaceId, key, value, options) {
+  const response = await requestKVValue(accountId, namespaceId, key, {
+    method: "PUT",
+    value
+  }, options);
+  if (!response.ok) {
+    await throwCloudflareResponseError(response, "KV write failed");
+  }
+}
+
+export { hasWranglerConfig, getWranglerAuth, getApiToken, isAuthenticated, CloudflareAPIError, AuthenticationError, apiGet, apiPost, apiPut, apiPatch, apiDelete, apiGetAll, kvGet, kvPut };

package/dist/{index-rfhx0yd5.js → index-11m5a8wd.js}

@@ -1,25 +1,63 @@
 import {
-  normalizeDOBinding
-} from "./index-wyf3s77s.js";
+  getSingleBrowserBindingName,
+  normalizeD1Binding,
+  normalizeDOBinding,
+  normalizeHyperdriveBinding,
+  normalizeKVBinding,
+  resolveConfigForEnvironment
+} from "./index-yzddwp02.js";
 import {
   __require
 } from "./index-37x76zdn.js";
 
-// src/config/resolve.ts
-import { defu } from "defu";
-function resolveConfigForEnvironment(config, environment) {
-  if (environment && config.env?.[environment]) {
-    return defu(config.env[environment], config);
+// src/config/compiler.ts
+import { basename, isAbsolute, relative, resolve } from "pathe";
+function getWranglerD1DatabaseId(bindingName, bindingConfig) {
+  const normalized = normalizeD1Binding(bindingConfig);
+  if (normalized.databaseId) {
+    return normalized.databaseId;
   }
-  return config;
+  throw new Error(`D1 binding "${bindingName}" is configured by name (${normalized.name}) and must be resolved before compiling Wrangler config. Use loadResolvedConfig() or resolveConfigResources() for build/deploy/automation flows.`);
+}
+function getWranglerKVNamespaceId(bindingName, bindingConfig) {
+  const normalized = normalizeKVBinding(bindingConfig);
+  if (normalized.namespaceId) {
+    return normalized.namespaceId;
+  }
+  throw new Error(`KV binding "${bindingName}" is configured by name (${normalized.name}) and must be resolved before compiling Wrangler config. Use loadResolvedConfig() or resolveConfigResources() for build/deploy/automation flows.`);
+}
+function getWranglerHyperdriveId(bindingName, bindingConfig) {
+  const normalized = normalizeHyperdriveBinding(bindingConfig);
+  if (normalized.configurationId) {
+    return normalized.configurationId;
+  }
+  throw new Error(`Hyperdrive binding "${bindingName}" is configured by name (${normalized.name}) and must be resolved before compiling Wrangler config. Use loadResolvedConfig() or resolveConfigResources() for build/deploy/automation flows.`);
+}
+function getWranglerBrowserBinding(browserBindings) {
+  const bindingName = getSingleBrowserBindingName(browserBindings);
+  return bindingName ? { binding: bindingName } : undefined;
+}
+function compileWranglerMigrations(migrations) {
+  return migrations.map((migration) => ({
+    tag: migration.tag,
+    ...migration.new_classes && { new_classes: migration.new_classes },
+    ...migration.renamed_classes && {
+      renamed_classes: migration.renamed_classes.map((renamedClass) => ({
+        from: renamedClass.from,
+        to: renamedClass.to
+      }))
+    },
+    ...migration.deleted_classes && { deleted_classes: migration.deleted_classes },
+    ...migration.new_sqlite_classes && { new_sqlite_classes: migration.new_sqlite_classes }
+  }));
 }
-
-// src/config/compiler.ts
 function compileConfig(config, environment) {
   const mergedConfig = resolveConfigForEnvironment(config, environment);
   const result = {
     name: mergedConfig.name,
-    compatibility_date: mergedConfig.compatibilityDate
+    compatibility_date: mergedConfig.compatibilityDate,
+    preview_urls: true,
+    workers_dev: true
   };
   if (mergedConfig.accountId) {
     result.account_id = mergedConfig.accountId;
@@ -61,18 +99,7 @@ function compileConfig(config, environment) {
     result.limits = mergedConfig.limits;
   }
   if (mergedConfig.migrations && mergedConfig.migrations.length > 0) {
-    result.migrations = mergedConfig.migrations.map((migration) => ({
-      tag: migration.tag,
-      ...migration.new_classes && { new_classes: migration.new_classes },
-      ...migration.renamed_classes && {
-        renamed_classes: migration.renamed_classes.map((rc) => ({
-          from: rc.from,
-          to: rc.to
-        }))
-      },
-      ...migration.deleted_classes && { deleted_classes: migration.deleted_classes },
-      ...migration.new_sqlite_classes && { new_sqlite_classes: migration.new_sqlite_classes }
-    }));
+    result.migrations = compileWranglerMigrations(mergedConfig.migrations);
   }
   if (mergedConfig.wrangler?.passthrough) {
     Object.assign(result, mergedConfig.wrangler.passthrough);
@@ -85,15 +112,15 @@ function compileToProgrammaticConfig(config, environment) {
 }
 function compileBindings(bindings, result) {
   if (bindings.kv) {
-    result.kv_namespaces = Object.entries(bindings.kv).map(([binding, id]) => ({
+    result.kv_namespaces = Object.entries(bindings.kv).map(([binding, namespace]) => ({
       binding,
-      id
+      id: getWranglerKVNamespaceId(binding, namespace)
     }));
   }
   if (bindings.d1) {
     result.d1_databases = Object.entries(bindings.d1).map(([binding, database_id]) => ({
       binding,
-      database_id
+      database_id: getWranglerD1DatabaseId(binding, database_id)
     }));
   }
   if (bindings.r2) {
@@ -154,11 +181,12 @@ function compileBindings(bindings, result) {
   if (bindings.hyperdrive) {
     result.hyperdrive = Object.entries(bindings.hyperdrive).map(([binding, config]) => ({
       binding,
-      id: config.id
+      id: getWranglerHyperdriveId(binding, config)
     }));
   }
-  if (bindings.browser && bindings.browser.binding) {
-    result.browser = { binding: bindings.browser.binding };
+  const browserBinding = getWranglerBrowserBinding(bindings.browser);
+  if (browserBinding) {
+    result.browser = browserBinding;
   }
   if (bindings.analyticsEngine) {
     result.analytics_engine_datasets = Object.entries(bindings.analyticsEngine).map(([binding, config]) => ({
@@ -188,15 +216,65 @@ function stringifyConfig(config) {
 `;
   return header + JSON.stringify(config, null, "\t");
 }
+function rebasePathForConfigDir(projectRoot, configDir, pathValue) {
+  const absolutePath = isAbsolute(pathValue) ? pathValue : resolve(projectRoot, pathValue);
+  return relative(configDir, absolutePath).replace(/\\/g, "/");
+}
+function pathIsInsideDirectory(directoryPath, candidatePath) {
+  const normalizedDirectoryPath = directoryPath.replace(/\\/g, "/");
+  const normalizedCandidatePath = candidatePath.replace(/\\/g, "/");
+  return normalizedCandidatePath === normalizedDirectoryPath || normalizedCandidatePath.startsWith(`${normalizedDirectoryPath}/`);
+}
+function isolateViteBuildOutputPaths(projectRoot, config) {
+  const assetsDirectory = config.assets?.directory;
+  if (!assetsDirectory) {
+    return config;
+  }
+  const isolatedAssetsDirectoryPath = resolve(projectRoot, ".devflare", "vite-build-output", basename(assetsDirectory));
+  const isolatedAssetsDirectory = relative(projectRoot, isolatedAssetsDirectoryPath).replace(/\\/g, "/");
+  const isolatedConfig = {
+    ...config,
+    assets: config.assets ? {
+      ...config.assets,
+      directory: isolatedAssetsDirectory
+    } : config.assets
+  };
+  if (!config.main) {
+    return isolatedConfig;
+  }
+  const originalAssetsDirectoryPath = resolve(projectRoot, assetsDirectory);
+  const originalMainEntryPath = resolve(projectRoot, config.main);
+  if (!pathIsInsideDirectory(originalAssetsDirectoryPath, originalMainEntryPath)) {
+    return isolatedConfig;
+  }
+  const relativeMainEntryPath = relative(originalAssetsDirectoryPath, originalMainEntryPath);
+  const isolatedMainEntryPath = resolve(isolatedAssetsDirectoryPath, relativeMainEntryPath);
+  return {
+    ...isolatedConfig,
+    main: relative(projectRoot, isolatedMainEntryPath).replace(/\\/g, "/")
+  };
+}
+function rebaseWranglerConfigPaths(projectRoot, configDir, config) {
+  return {
+    ...config,
+    ...config.main ? { main: rebasePathForConfigDir(projectRoot, configDir, config.main) } : {},
+    ...config.assets?.directory ? {
+      assets: {
+        ...config.assets,
+        directory: rebasePathForConfigDir(projectRoot, configDir, config.assets.directory)
+      }
+    } : {}
+  };
+}
 async function writeWranglerConfig(cwd, config, filename = "wrangler.jsonc") {
-  const { resolve } = await import("pathe");
+  const { resolve: resolve2 } = await import("pathe");
   const fs = await import("node:fs/promises");
   try {
     await fs.mkdir(cwd, { recursive: true });
   } catch {}
   const content = stringifyConfig(config);
-  const wranglerPath = resolve(cwd, filename);
+  const wranglerPath = resolve2(cwd, filename);
   await fs.writeFile(wranglerPath, content, "utf-8");
   return wranglerPath;
 }
-export { resolveConfigForEnvironment, compileConfig, compileToProgrammaticConfig, stringifyConfig, writeWranglerConfig };
+export { compileConfig, compileToProgrammaticConfig, stringifyConfig, isolateViteBuildOutputPaths, rebaseWranglerConfigPaths, writeWranglerConfig };