devflare 1.0.0-next.13 → 1.0.0-next.15

package/dist/index-7bq4xq84.js

@@ -0,0 +1,197 @@
+import {
+  apiGet,
+  apiPost,
+  getEffectiveAccountId,
+  getPrimaryAccount,
+  isAuthenticated,
+  kvGet,
+  kvPut
+} from "./index-xdq9ery1.js";
+
+// src/cloudflare/usage.ts
+var DEVFLARE_KV_NAMESPACE_TITLE = "devflare-usage";
+var USAGE_KEY_PREFIX = "usage:";
+var LIMITS_KEY = "limits";
+var DEFAULT_LIMITS = {
+  aiTokensPerDay: 1e4,
+  aiRequestsPerDay: 100,
+  vectorizeOpsPerDay: 1000,
+  enabled: true
+};
+async function getOrCreateUsageNamespace(accountId) {
+  const namespaces = await apiGet(`/accounts/${accountId}/storage/kv/namespaces`);
+  const existing = namespaces.find((ns) => ns.title === DEVFLARE_KV_NAMESPACE_TITLE);
+  if (existing) {
+    return existing.id;
+  }
+  const created = await apiPost(`/accounts/${accountId}/storage/kv/namespaces`, { title: DEVFLARE_KV_NAMESPACE_TITLE });
+  return created.id;
+}
+function getTodayDate() {
+  return new Date().toISOString().split("T")[0];
+}
+function buildUsageKey(service, date) {
+  return `${USAGE_KEY_PREFIX}${service}:${date}`;
+}
+async function getUsage(accountId, service, date) {
+  const targetDate = date ?? getTodayDate();
+  const namespaceId = await getOrCreateUsageNamespace(accountId);
+  const key = buildUsageKey(service, targetDate);
+  const value = await kvGet(accountId, namespaceId, key);
+  if (value === null) {
+    return null;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+async function recordUsage(accountId, service, count = 1) {
+  const today = getTodayDate();
+  const namespaceId = await getOrCreateUsageNamespace(accountId);
+  const key = buildUsageKey(service, today);
+  const existing = await getUsage(accountId, service, today);
+  const currentCount = existing?.count ?? 0;
+  const record = {
+    service,
+    date: today,
+    count: currentCount + count,
+    updatedAt: new Date().toISOString()
+  };
+  await kvPut(accountId, namespaceId, key, JSON.stringify(record));
+  return record;
+}
+async function resetUsage(accountId, service) {
+  const today = getTodayDate();
+  const namespaceId = await getOrCreateUsageNamespace(accountId);
+  const key = buildUsageKey(service, today);
+  const record = {
+    service,
+    date: today,
+    count: 0,
+    updatedAt: new Date().toISOString()
+  };
+  await kvPut(accountId, namespaceId, key, JSON.stringify(record));
+}
+async function getLimits(accountId) {
+  const namespaceId = await getOrCreateUsageNamespace(accountId);
+  const value = await kvGet(accountId, namespaceId, LIMITS_KEY);
+  if (value === null) {
+    return DEFAULT_LIMITS;
+  }
+  try {
+    return { ...DEFAULT_LIMITS, ...JSON.parse(value) };
+  } catch {
+    return DEFAULT_LIMITS;
+  }
+}
+async function setLimits(accountId, limits) {
+  const namespaceId = await getOrCreateUsageNamespace(accountId);
+  const current = await getLimits(accountId);
+  const updated = {
+    ...current,
+    ...limits
+  };
+  await kvPut(accountId, namespaceId, LIMITS_KEY, JSON.stringify(updated));
+  return updated;
+}
+async function setLimitsEnabled(accountId, enabled) {
+  return setLimits(accountId, { enabled });
+}
+async function isWithinLimits(accountId, service) {
+  const limits = await getLimits(accountId);
+  if (!limits.enabled) {
+    return true;
+  }
+  const usage = await getUsage(accountId, service);
+  const currentCount = usage?.count ?? 0;
+  switch (service) {
+    case "ai":
+      if (limits.aiRequestsPerDay && currentCount >= limits.aiRequestsPerDay) {
+        return false;
+      }
+      return true;
+    case "vectorize":
+      if (limits.vectorizeOpsPerDay && currentCount >= limits.vectorizeOpsPerDay) {
+        return false;
+      }
+      return true;
+    default:
+      return true;
+  }
+}
+async function getUsageSummary(accountId, service) {
+  const limits = await getLimits(accountId);
+  const usage = await getUsage(accountId, service);
+  const currentCount = usage?.count ?? 0;
+  let limit;
+  switch (service) {
+    case "ai":
+      limit = limits.aiRequestsPerDay;
+      break;
+    case "vectorize":
+      limit = limits.vectorizeOpsPerDay;
+      break;
+  }
+  const withinLimit = limit === undefined || currentCount < limit;
+  const percentUsed = limit ? currentCount / limit * 100 : undefined;
+  return {
+    service,
+    today: currentCount,
+    limit,
+    withinLimit,
+    percentUsed
+  };
+}
+async function getAllUsageSummaries(accountId) {
+  const trackedServices = ["ai", "vectorize"];
+  return Promise.all(trackedServices.map((s) => getUsageSummary(accountId, s)));
+}
+async function canProceedWithTest(accountId, service) {
+  const limits = await getLimits(accountId);
+  if (!limits.enabled) {
+    return { allowed: true };
+  }
+  const withinLimits = await isWithinLimits(accountId, service);
+  if (!withinLimits) {
+    const summary = await getUsageSummary(accountId, service);
+    return {
+      allowed: false,
+      reason: `Daily limit exceeded for ${service}: ${summary.today}/${summary.limit} (${summary.percentUsed?.toFixed(1)}%)`
+    };
+  }
+  return { allowed: true };
+}
+async function recordTestUsage(accountId, service, count = 1) {
+  await recordUsage(accountId, service, count);
+}
+async function shouldSkip(service) {
+  try {
+    const isAuth = await isAuthenticated();
+    if (!isAuth) {
+      console.log(`⏭️  ${service.toUpperCase()} tests skipped: Not authenticated. Run: bunx wrangler login`);
+      return true;
+    }
+    const primary = await getPrimaryAccount();
+    if (!primary) {
+      console.log(`⏭️  ${service.toUpperCase()} tests skipped: No Cloudflare account found`);
+      return true;
+    }
+    const { accountId } = await getEffectiveAccountId(primary.id);
+    try {
+      const { allowed, reason } = await canProceedWithTest(accountId, service);
+      if (!allowed) {
+        console.log(`⏭️  ${service.toUpperCase()} tests skipped: ${reason}`);
+        return true;
+      }
+    } catch {}
+    return false;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.log(`⏭️  ${service.toUpperCase()} tests skipped: ${message}`);
+    return true;
+  }
+}
+
+export { getUsage, recordUsage, resetUsage, getLimits, setLimits, setLimitsEnabled, isWithinLimits, getUsageSummary, getAllUsageSummaries, canProceedWithTest, recordTestUsage, shouldSkip };

package/dist/{index-dr6sbp8d.js → index-k8vh558d.js}

@@ -1,6 +1,6 @@
 import {
   resolveConfigPath
-} from "./index-wyf3s77s.js";
+} from "./index-tksw7gpy.js";
 
 // src/cli/config-path.ts
 import { stat } from "node:fs/promises";

package/dist/{index-wyf3s77s.js → index-tksw7gpy.js}

@@ -1,3 +1,9 @@
+import {
+  getEffectiveAccountId,
+  getPrimaryAccount,
+  listD1Databases
+} from "./index-xdq9ery1.js";
+
 // src/config/schema.ts
 import { z } from "zod";
 var dateRegex = /^\d{4}-\d{2}-\d{2}$/;
@@ -79,9 +85,20 @@ var sendEmailBindingSchema = z.object({
   message: "sendEmail bindings must use either destinationAddress or allowedDestinationAddresses, not both",
   path: ["allowedDestinationAddresses"]
 });
+var d1BindingByIdSchema = z.object({
+  id: z.string()
+}).strict();
+var d1BindingByNameSchema = z.object({
+  name: z.string()
+}).strict();
+var d1BindingSchema = z.union([
+  z.string(),
+  d1BindingByIdSchema,
+  d1BindingByNameSchema
+]);
 var bindingsSchema = z.object({
   kv: z.record(z.string(), z.string()).optional(),
-  d1: z.record(z.string(), z.string()).optional(),
+  d1: z.record(z.string(), d1BindingSchema).optional(),
   r2: z.record(z.string(), z.string()).optional(),
   durableObjects: z.record(z.string(), durableObjectBindingSchema).optional(),
   queues: queuesConfigSchema.optional(),
@@ -269,6 +286,19 @@ function normalizeDOBinding(config) {
     __ref: config.__ref
   };
 }
+function normalizeD1Binding(config) {
+  if (typeof config === "string") {
+    return { databaseId: config };
+  }
+  if ("id" in config) {
+    return { databaseId: config.id };
+  }
+  return { name: config.name };
+}
+function getLocalD1DatabaseIdentifier(config) {
+  const normalized = normalizeD1Binding(config);
+  return normalized.databaseId ?? normalized.name ?? "";
+}
 
 // src/config/loader.ts
 import { loadConfig as c12LoadConfig } from "c12";
@@ -340,4 +370,134 @@ ${issueMessages}`);
   }
 }
 
-export { configSchema, normalizeDOBinding, resolveConfigPath, loadConfig, ConfigNotFoundError, ConfigValidationError };
+// src/config/resolve.ts
+import { defu } from "defu";
+function resolveConfigForEnvironment(config, environment) {
+  if (environment && config.env?.[environment]) {
+    return defu(config.env[environment], config);
+  }
+  return config;
+}
+
+// src/config/resource-resolution.ts
+var defaultCloudflareApi = {
+  getPrimaryAccount,
+  getEffectiveAccountId,
+  listD1Databases
+};
+
+class ConfigResourceResolutionError extends Error {
+  code = "CONFIG_RESOURCE_RESOLUTION_ERROR";
+  constructor(message, cause) {
+    super(message);
+    this.name = "ConfigResourceResolutionError";
+    if (cause !== undefined) {
+      this.cause = cause;
+    }
+  }
+}
+function resolveCloudflareApi(overrides) {
+  return {
+    ...defaultCloudflareApi,
+    ...overrides ?? {}
+  };
+}
+function materializeLocalD1Bindings(bindings) {
+  return Object.fromEntries(Object.entries(bindings).map(([bindingName, bindingConfig]) => {
+    return [bindingName, getLocalD1DatabaseIdentifier(bindingConfig)];
+  }));
+}
+async function resolveLookupAccountId(config, options, cloudflareApi) {
+  const explicitAccountId = options.accountId ?? config.accountId;
+  if (explicitAccountId) {
+    return explicitAccountId;
+  }
+  let primaryAccount;
+  try {
+    primaryAccount = await cloudflareApi.getPrimaryAccount();
+  } catch (error) {
+    throw new ConfigResourceResolutionError("Could not resolve D1 database names because Devflare could not read your Cloudflare accounts. Set accountId in devflare.config.ts, configure a workspace/global default account, or log in with Wrangler.", error);
+  }
+  if (!primaryAccount) {
+    throw new ConfigResourceResolutionError("Could not resolve D1 database names because no Cloudflare account is available. Set accountId in devflare.config.ts, configure a workspace/global default account, or log in with Wrangler.");
+  }
+  try {
+    const { accountId } = await cloudflareApi.getEffectiveAccountId(primaryAccount.id);
+    return accountId;
+  } catch (error) {
+    throw new ConfigResourceResolutionError(`Could not determine the effective Cloudflare account for D1 name resolution after selecting primary account ${primaryAccount.id}.`, error);
+  }
+}
+function formatMissingD1Bindings(missing) {
+  return missing.map(({ bindingName, databaseName }) => `${bindingName} → ${databaseName}`).join(", ");
+}
+function resolveConfigForLocalRuntime(config, environment) {
+  const resolvedConfig = resolveConfigForEnvironment(config, environment);
+  if (!resolvedConfig.bindings?.d1) {
+    return resolvedConfig;
+  }
+  return {
+    ...resolvedConfig,
+    bindings: {
+      ...resolvedConfig.bindings,
+      d1: materializeLocalD1Bindings(resolvedConfig.bindings.d1)
+    }
+  };
+}
+async function resolveConfigResources(config, options = {}) {
+  const resolvedConfig = resolveConfigForEnvironment(config, options.environment);
+  const d1Bindings = resolvedConfig.bindings?.d1;
+  if (!d1Bindings) {
+    return resolvedConfig;
+  }
+  const pendingNameBindings = Object.entries(d1Bindings).map(([bindingName, bindingConfig]) => {
+    const normalized = normalizeD1Binding(bindingConfig);
+    return normalized.databaseId ? null : {
+      bindingName,
+      databaseName: normalized.name ?? ""
+    };
+  }).filter((binding) => binding !== null);
+  if (pendingNameBindings.length === 0) {
+    return {
+      ...resolvedConfig,
+      bindings: {
+        ...resolvedConfig.bindings,
+        d1: materializeLocalD1Bindings(d1Bindings)
+      }
+    };
+  }
+  const cloudflareApi = resolveCloudflareApi(options.cloudflare);
+  const accountId = await resolveLookupAccountId(resolvedConfig, options, cloudflareApi);
+  let databases;
+  try {
+    databases = await cloudflareApi.listD1Databases(accountId);
+  } catch (error) {
+    throw new ConfigResourceResolutionError(`Could not list D1 databases for Cloudflare account ${accountId} while resolving name-based D1 bindings.`, error);
+  }
+  const databaseIdsByName = new Map(databases.map((database) => [database.name, database.id]));
+  const missingBindings = pendingNameBindings.filter(({ databaseName }) => {
+    return !databaseIdsByName.has(databaseName);
+  });
+  if (missingBindings.length > 0) {
+    throw new ConfigResourceResolutionError(`Could not find D1 database(s) for ${formatMissingD1Bindings(missingBindings)} in Cloudflare account ${accountId}.`);
+  }
+  return {
+    ...resolvedConfig,
+    bindings: {
+      ...resolvedConfig.bindings,
+      d1: Object.fromEntries(Object.entries(d1Bindings).map(([bindingName, bindingConfig]) => {
+        const normalized = normalizeD1Binding(bindingConfig);
+        return [
+          bindingName,
+          normalized.databaseId ?? databaseIdsByName.get(normalized.name ?? "") ?? ""
+        ];
+      }))
+    }
+  };
+}
+async function loadResolvedConfig(options = {}) {
+  const config = await loadConfig(options);
+  return resolveConfigResources(config, options);
+}
+
+export { configSchema, normalizeDOBinding, normalizeD1Binding, getLocalD1DatabaseIdentifier, resolveConfigForEnvironment, ConfigResourceResolutionError, resolveConfigForLocalRuntime, resolveConfigResources, loadResolvedConfig, resolveConfigPath, loadConfig, ConfigNotFoundError, ConfigValidationError };

package/dist/{index-8x16kn47.js → index-v43z02tr.js}

@@ -7,7 +7,7 @@ import {
 
 // src/cli/index.ts
 import { createConsola } from "consola";
-var COMMANDS = ["init", "dev", "build", "deploy", "types", "doctor", "account", "ai", "remote", "help", "version"];
+var COMMANDS = ["init", "dev", "build", "deploy", "types", "doctor", "config", "account", "ai", "remote", "help", "version"];
 function parseArgs(argv) {
   const args = [];
   const options = {};
@@ -62,6 +62,7 @@ Commands:
 	deploy              Deploy to Cloudflare
 	types               Generate TypeScript types
 	doctor              Check project configuration
+	config              Print resolved Devflare/Wrangler config
 	account             View Cloudflare account info
 	ai                  View AI models and pricing
 	remote              Manage remote test mode (AI, Vectorize)
@@ -69,7 +70,8 @@ Commands:
 	version             Show the installed devflare version
 
 Common Options:
-	--config <path>     Used by dev, build, deploy, types, and doctor
+	--config <path>     Used by dev, build, deploy, types, doctor, and config
+	--env <name>        Used by build, deploy, and config to select config.env[name]
 	--debug             Enable debug output for supported commands
 	-h, --help          Show help
 	-v, --version       Show version
@@ -89,6 +91,8 @@ Build / Deploy:
 Types / Doctor:
 	types --output <path>       Write generated types to a custom path
 	doctor --config <path>      Check a specific devflare config file
+	config print --json         Print resolved config as JSON
+	config print --format wrangler  Print resolved Wrangler config JSON
 
 Account / Remote:
 	account --account <id>      Use a specific Cloudflare account
@@ -144,6 +148,8 @@ async function runCli(argv, options = {}) {
       return runTypes(parsed, logger, options);
     case "doctor":
       return runDoctor(parsed, logger, options);
+    case "config":
+      return runConfig(parsed, logger, options);
     case "account":
       return runAccount(parsed, logger, options);
     case "ai":
@@ -160,27 +166,31 @@ async function runInit(parsed, logger, options) {
   return runInitCommand(parsed, logger, options);
 }
 async function runDev(parsed, logger, options) {
-  const { runDevCommand } = await import("./dev-mqsffeeb.js");
+  const { runDevCommand } = await import("./dev-ymtphbkg.js");
   return runDevCommand(parsed, logger, options);
 }
 async function runBuild(parsed, logger, options) {
-  const { runBuildCommand } = await import("./build-e6kgjwr8.js");
+  const { runBuildCommand } = await import("./build-zv25ke4s.js");
   return runBuildCommand(parsed, logger, options);
 }
 async function runDeploy(parsed, logger, options) {
-  const { runDeployCommand } = await import("./deploy-eeaqwxaa.js");
+  const { runDeployCommand } = await import("./deploy-6xmqvv06.js");
   return runDeployCommand(parsed, logger, options);
 }
 async function runTypes(parsed, logger, options) {
-  const { runTypesCommand } = await import("./types-sffr9681.js");
+  const { runTypesCommand } = await import("./types-158m16vd.js");
   return runTypesCommand(parsed, logger, options);
 }
 async function runDoctor(parsed, logger, options) {
-  const { runDoctorCommand } = await import("./doctor-z4ffybce.js");
+  const { runDoctorCommand } = await import("./doctor-xv4gm1h4.js");
   return runDoctorCommand(parsed, logger, options);
 }
+async function runConfig(parsed, logger, options) {
+  const { runConfigCommand } = await import("./config-v9tr4rts.js");
+  return runConfigCommand(parsed, logger, options);
+}
 async function runAccount(parsed, logger, options) {
-  const { runAccountCommand } = await import("./account-8psavtg6.js");
+  const { runAccountCommand } = await import("./account-spa7gzsn.js");
   return runAccountCommand(parsed, logger, options);
 }
 async function runAI() {

package/dist/{index-tfyxa77h.js → index-xdq9ery1.js}

@@ -661,190 +661,4 @@ async function clearGlobalDefaultAccountId(anyAccountId) {
   } catch {}
 }
 
-// src/cloudflare/usage.ts
-var DEVFLARE_KV_NAMESPACE_TITLE2 = "devflare-usage";
-var USAGE_KEY_PREFIX = "usage:";
-var LIMITS_KEY = "limits";
-var DEFAULT_LIMITS = {
-  aiTokensPerDay: 1e4,
-  aiRequestsPerDay: 100,
-  vectorizeOpsPerDay: 1000,
-  enabled: true
-};
-async function getOrCreateUsageNamespace(accountId) {
-  const namespaces = await apiGet(`/accounts/${accountId}/storage/kv/namespaces`);
-  const existing = namespaces.find((ns) => ns.title === DEVFLARE_KV_NAMESPACE_TITLE2);
-  if (existing) {
-    return existing.id;
-  }
-  const created = await apiPost(`/accounts/${accountId}/storage/kv/namespaces`, { title: DEVFLARE_KV_NAMESPACE_TITLE2 });
-  return created.id;
-}
-function getTodayDate() {
-  return new Date().toISOString().split("T")[0];
-}
-function buildUsageKey(service, date) {
-  return `${USAGE_KEY_PREFIX}${service}:${date}`;
-}
-async function getUsage(accountId, service, date) {
-  const targetDate = date ?? getTodayDate();
-  const namespaceId = await getOrCreateUsageNamespace(accountId);
-  const key = buildUsageKey(service, targetDate);
-  const value = await kvGet(accountId, namespaceId, key);
-  if (value === null) {
-    return null;
-  }
-  try {
-    return JSON.parse(value);
-  } catch {
-    return null;
-  }
-}
-async function recordUsage(accountId, service, count = 1) {
-  const today = getTodayDate();
-  const namespaceId = await getOrCreateUsageNamespace(accountId);
-  const key = buildUsageKey(service, today);
-  const existing = await getUsage(accountId, service, today);
-  const currentCount = existing?.count ?? 0;
-  const record = {
-    service,
-    date: today,
-    count: currentCount + count,
-    updatedAt: new Date().toISOString()
-  };
-  await kvPut(accountId, namespaceId, key, JSON.stringify(record));
-  return record;
-}
-async function resetUsage(accountId, service) {
-  const today = getTodayDate();
-  const namespaceId = await getOrCreateUsageNamespace(accountId);
-  const key = buildUsageKey(service, today);
-  const record = {
-    service,
-    date: today,
-    count: 0,
-    updatedAt: new Date().toISOString()
-  };
-  await kvPut(accountId, namespaceId, key, JSON.stringify(record));
-}
-async function getLimits(accountId) {
-  const namespaceId = await getOrCreateUsageNamespace(accountId);
-  const value = await kvGet(accountId, namespaceId, LIMITS_KEY);
-  if (value === null) {
-    return DEFAULT_LIMITS;
-  }
-  try {
-    return { ...DEFAULT_LIMITS, ...JSON.parse(value) };
-  } catch {
-    return DEFAULT_LIMITS;
-  }
-}
-async function setLimits(accountId, limits) {
-  const namespaceId = await getOrCreateUsageNamespace(accountId);
-  const current = await getLimits(accountId);
-  const updated = {
-    ...current,
-    ...limits
-  };
-  await kvPut(accountId, namespaceId, LIMITS_KEY, JSON.stringify(updated));
-  return updated;
-}
-async function setLimitsEnabled(accountId, enabled) {
-  return setLimits(accountId, { enabled });
-}
-async function isWithinLimits(accountId, service) {
-  const limits = await getLimits(accountId);
-  if (!limits.enabled) {
-    return true;
-  }
-  const usage = await getUsage(accountId, service);
-  const currentCount = usage?.count ?? 0;
-  switch (service) {
-    case "ai":
-      if (limits.aiRequestsPerDay && currentCount >= limits.aiRequestsPerDay) {
-        return false;
-      }
-      return true;
-    case "vectorize":
-      if (limits.vectorizeOpsPerDay && currentCount >= limits.vectorizeOpsPerDay) {
-        return false;
-      }
-      return true;
-    default:
-      return true;
-  }
-}
-async function getUsageSummary(accountId, service) {
-  const limits = await getLimits(accountId);
-  const usage = await getUsage(accountId, service);
-  const currentCount = usage?.count ?? 0;
-  let limit;
-  switch (service) {
-    case "ai":
-      limit = limits.aiRequestsPerDay;
-      break;
-    case "vectorize":
-      limit = limits.vectorizeOpsPerDay;
-      break;
-  }
-  const withinLimit = limit === undefined || currentCount < limit;
-  const percentUsed = limit ? currentCount / limit * 100 : undefined;
-  return {
-    service,
-    today: currentCount,
-    limit,
-    withinLimit,
-    percentUsed
-  };
-}
-async function getAllUsageSummaries(accountId) {
-  const trackedServices = ["ai", "vectorize"];
-  return Promise.all(trackedServices.map((s) => getUsageSummary(accountId, s)));
-}
-async function canProceedWithTest(accountId, service) {
-  const limits = await getLimits(accountId);
-  if (!limits.enabled) {
-    return { allowed: true };
-  }
-  const withinLimits = await isWithinLimits(accountId, service);
-  if (!withinLimits) {
-    const summary = await getUsageSummary(accountId, service);
-    return {
-      allowed: false,
-      reason: `Daily limit exceeded for ${service}: ${summary.today}/${summary.limit} (${summary.percentUsed?.toFixed(1)}%)`
-    };
-  }
-  return { allowed: true };
-}
-async function recordTestUsage(accountId, service, count = 1) {
-  await recordUsage(accountId, service, count);
-}
-async function shouldSkip(service) {
-  try {
-    const isAuth = await isAuthenticated();
-    if (!isAuth) {
-      console.log(`⏭️  ${service.toUpperCase()} tests skipped: Not authenticated. Run: bunx wrangler login`);
-      return true;
-    }
-    const primary = await getPrimaryAccount();
-    if (!primary) {
-      console.log(`⏭️  ${service.toUpperCase()} tests skipped: No Cloudflare account found`);
-      return true;
-    }
-    const { accountId } = await getEffectiveAccountId(primary.id);
-    try {
-      const { allowed, reason } = await canProceedWithTest(accountId, service);
-      if (!allowed) {
-        console.log(`⏭️  ${service.toUpperCase()} tests skipped: ${reason}`);
-        return true;
-      }
-    } catch {}
-    return false;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    console.log(`⏭️  ${service.toUpperCase()} tests skipped: ${message}`);
-    return true;
-  }
-}
-
-export { hasWranglerConfig, getWranglerAuth, getApiToken, isAuthenticated, CloudflareAPIError, AuthenticationError, getAccounts, getPrimaryAccount, getAccountById, listWorkers, listKVNamespaces, listD1Databases, listR2Buckets, listVectorizeIndexes, listAIModels, getServiceStatus, getAllServiceStatus, hasService, getAccountSummary, getWorkspaceAccountId, setWorkspaceAccountId, getGlobalDefaultAccountId, setGlobalDefaultAccountId, getEffectiveAccountId, clearGlobalDefaultAccountId, getUsage, recordUsage, resetUsage, getLimits, setLimits, setLimitsEnabled, isWithinLimits, getUsageSummary, getAllUsageSummaries, canProceedWithTest, recordTestUsage, shouldSkip };
+export { hasWranglerConfig, getWranglerAuth, getApiToken, isAuthenticated, CloudflareAPIError, AuthenticationError, apiGet, apiPost, kvGet, kvPut, getAccounts, getPrimaryAccount, getAccountById, listWorkers, listKVNamespaces, listD1Databases, listR2Buckets, listVectorizeIndexes, listAIModels, getServiceStatus, getAllServiceStatus, hasService, getAccountSummary, getWorkspaceAccountId, setWorkspaceAccountId, getGlobalDefaultAccountId, setGlobalDefaultAccountId, getEffectiveAccountId, clearGlobalDefaultAccountId };