devflare 1.0.0-next.2 → 1.0.0-next.21

package/dist/index-tfyxa77h.js

@@ -1,850 +0,0 @@
-// 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 timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const response = await Promise.race([
-      fetch(url, { ...init, signal: controller.signal }),
-      new Promise((_, reject) => setTimeout(() => reject(new Error(`Request timed out after ${timeoutMs}ms`)), timeoutMs))
-    ]);
-    return response;
-  } finally {
-    clearTimeout(timeoutId);
-  }
-}
-
-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: bunx wrangler 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 apiGet(path, options) {
-  const makeRequest = async (forceRefresh) => {
-    const headers = await createHeaders(options, forceRefresh);
-    const url = `${API_BASE}${path}`;
-    const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
-    const response2 = await fetchWithTimeout(url, {
-      method: "GET",
-      headers
-    }, timeout);
-    const data2 = await response2.json();
-    return { response: response2, data: data2 };
-  };
-  let { response, data } = await makeRequest(false);
-  if (isAuthError(response, data) && !hasRetriedWithFreshToken && !options?.token) {
-    hasRetriedWithFreshToken = true;
-    invalidateToken();
-    ({ response, data } = await makeRequest(true));
-    hasRetriedWithFreshToken = false;
-  }
-  if (!data.success) {
-    throw new CloudflareAPIError(data.errors[0]?.message || "API request failed", response.status, data.errors);
-  }
-  return data.result;
-}
-async function apiPost(path, body, options) {
-  const headers = await createHeaders(options);
-  const url = `${API_BASE}${path}`;
-  const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
-  const response = await fetchWithTimeout(url, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body)
-  }, timeout);
-  const data = await response.json();
-  if (!data.success) {
-    throw new CloudflareAPIError(data.errors[0]?.message || "API request failed", response.status, data.errors);
-  }
-  return data.result;
-}
-async function apiGetAll(path, options) {
-  const results = [];
-  let page = 1;
-  const perPage = 50;
-  const maxPages = 100;
-  while (page <= maxPages) {
-    const separator = path.includes("?") ? "&" : "?";
-    const pagedPath = `${path}${separator}page=${page}&per_page=${perPage}`;
-    const headers = await createHeaders(options);
-    const url = `${API_BASE}${pagedPath}`;
-    const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
-    const response = await fetchWithTimeout(url, {
-      method: "GET",
-      headers
-    }, timeout);
-    const data = await response.json();
-    if (!data.success) {
-      throw new CloudflareAPIError(data.errors[0]?.message || "API request failed", response.status, data.errors);
-    }
-    results.push(...data.result);
-    if (!data.result_info) {
-      break;
-    }
-    if (data.result.length === 0) {
-      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 kvGet(accountId, namespaceId, key, 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}`;
-  const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
-  const response = await fetchWithTimeout(url, {
-    method: "GET",
-    headers: { Authorization: `Bearer ${token}` }
-  }, timeout);
-  if (response.status === 404) {
-    return null;
-  }
-  if (!response.ok) {
-    try {
-      const errorData = await response.json();
-      throw new CloudflareAPIError(errorData.errors[0]?.message || "KV read failed", response.status, errorData.errors);
-    } catch {
-      throw new CloudflareAPIError("KV read failed", response.status, []);
-    }
-  }
-  return response.text();
-}
-async function kvPut(accountId, namespaceId, key, value, 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}`;
-  const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
-  const response = await fetchWithTimeout(url, {
-    method: "PUT",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "text/plain"
-    },
-    body: value
-  }, timeout);
-  if (!response.ok) {
-    try {
-      const errorData = await response.json();
-      throw new CloudflareAPIError(errorData.errors[0]?.message || "KV write failed", response.status, errorData.errors);
-    } catch {
-      throw new CloudflareAPIError("KV write failed", response.status, []);
-    }
-  }
-}
-
-// src/cloudflare/account.ts
-async function getAccounts() {
-  const accounts = await apiGetAll("/accounts");
-  return accounts.map((acc) => ({
-    id: acc.id,
-    name: acc.name,
-    type: acc.type,
-    createdOn: acc.created_on ? new Date(acc.created_on) : undefined
-  }));
-}
-async function getPrimaryAccount() {
-  const accounts = await getAccounts();
-  return accounts[0] ?? null;
-}
-async function getAccountById(accountId) {
-  try {
-    const account = await apiGet(`/accounts/${accountId}`);
-    return {
-      id: account.id,
-      name: account.name,
-      type: account.type,
-      createdOn: account.created_on ? new Date(account.created_on) : undefined
-    };
-  } catch {
-    return null;
-  }
-}
-async function listWorkers(accountId, options) {
-  const scripts = await apiGetAll(`/accounts/${accountId}/workers/scripts`, options);
-  return scripts.map((s) => ({
-    name: s.name ?? s.id,
-    createdOn: new Date(s.created_on),
-    modifiedOn: new Date(s.modified_on)
-  }));
-}
-async function listKVNamespaces(accountId, options) {
-  const namespaces = await apiGetAll(`/accounts/${accountId}/storage/kv/namespaces`, options);
-  return namespaces.map((ns) => ({
-    id: ns.id,
-    name: ns.title
-  }));
-}
-async function listD1Databases(accountId, options) {
-  const databases = await apiGetAll(`/accounts/${accountId}/d1/database`, options);
-  return databases.map((db) => ({
-    id: db.uuid,
-    name: db.name,
-    version: db.version,
-    tableCount: db.num_tables,
-    sizeBytes: db.file_size
-  }));
-}
-async function listR2Buckets(accountId, options) {
-  const buckets = await apiGetAll(`/accounts/${accountId}/r2/buckets`, options);
-  return buckets.map((b) => ({
-    name: b.name,
-    createdOn: new Date(b.creation_date),
-    location: b.location
-  }));
-}
-async function listVectorizeIndexes(accountId, options) {
-  try {
-    const indexes = await apiGetAll(`/accounts/${accountId}/vectorize/v2/indexes`, options);
-    return indexes.map((idx) => ({
-      name: idx.name,
-      dimensions: idx.config.dimensions,
-      metric: idx.config.metric,
-      description: idx.description
-    }));
-  } catch {
-    return [];
-  }
-}
-async function listAIModels(accountId, options) {
-  try {
-    const models = await apiGetAll(`/accounts/${accountId}/ai/models/search`, options);
-    return models.map((m) => ({
-      id: m.id,
-      name: m.name,
-      task: m.task?.name,
-      description: m.description
-    }));
-  } catch {
-    return [];
-  }
-}
-async function getServiceStatus(accountId, service) {
-  const timeout = 1e4;
-  try {
-    switch (service) {
-      case "workers": {
-        const workers = await Promise.race([
-          listWorkers(accountId),
-          new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), timeout))
-        ]);
-        return {
-          service,
-          available: true,
-          count: workers.length
-        };
-      }
-      case "kv": {
-        const namespaces = await Promise.race([
-          listKVNamespaces(accountId),
-          new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), timeout))
-        ]);
-        return {
-          service,
-          available: true,
-          count: namespaces.length
-        };
-      }
-      case "d1": {
-        const databases = await Promise.race([
-          listD1Databases(accountId),
-          new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), timeout))
-        ]);
-        return {
-          service,
-          available: true,
-          count: databases.length
-        };
-      }
-      case "r2": {
-        const buckets = await Promise.race([
-          listR2Buckets(accountId),
-          new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), timeout))
-        ]);
-        return {
-          service,
-          available: true,
-          count: buckets.length
-        };
-      }
-      case "vectorize": {
-        const indexes = await Promise.race([
-          listVectorizeIndexes(accountId),
-          new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), timeout))
-        ]);
-        return {
-          service,
-          available: true,
-          count: indexes.length
-        };
-      }
-      case "ai": {
-        const models = await Promise.race([
-          listAIModels(accountId),
-          new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), timeout))
-        ]);
-        return {
-          service,
-          available: models.length > 0,
-          count: models.length
-        };
-      }
-      default:
-        return {
-          service,
-          available: false
-        };
-    }
-  } catch {
-    return {
-      service,
-      available: false
-    };
-  }
-}
-async function getAllServiceStatus(accountId) {
-  const services = [
-    "workers",
-    "kv",
-    "d1",
-    "r2",
-    "vectorize",
-    "ai"
-  ];
-  const statuses = await Promise.all(services.map((s) => getServiceStatus(accountId, s)));
-  return statuses;
-}
-async function hasService(accountId, service) {
-  const status = await getServiceStatus(accountId, service);
-  return status.available;
-}
-async function getAccountSummary(accountId) {
-  const account = await getAccountById(accountId);
-  if (!account)
-    return null;
-  const services = await getAllServiceStatus(accountId);
-  return {
-    account,
-    services
-  };
-}
-
-// src/cloudflare/preferences.ts
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "node:fs";
-var DEVFLARE_KV_NAMESPACE_TITLE = "devflare-usage";
-var GLOBAL_ACCOUNT_KEY = "settings:defaultAccountId";
-var LOCAL_CACHE_DIR = ".devflare";
-var LOCAL_CACHE_FILE = "preferences.json";
-function getLocalPreferencesPath() {
-  return join2(homedir2(), LOCAL_CACHE_DIR, LOCAL_CACHE_FILE);
-}
-function readLocalPreferences() {
-  const path = getLocalPreferencesPath();
-  if (!existsSync2(path)) {
-    return {};
-  }
-  try {
-    const content = readFileSync2(path, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-function writeLocalPreferences(prefs) {
-  const path = getLocalPreferencesPath();
-  const dir = join2(homedir2(), LOCAL_CACHE_DIR);
-  if (!existsSync2(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  writeFileSync(path, JSON.stringify(prefs, null, "\t"), "utf-8");
-}
-function findPackageJsonPath(startDir) {
-  let dir = startDir ?? process.cwd();
-  while (dir !== join2(dir, "..")) {
-    const pkgPath = join2(dir, "package.json");
-    if (existsSync2(pkgPath)) {
-      return pkgPath;
-    }
-    dir = join2(dir, "..");
-  }
-  return null;
-}
-function readPackageJson(path) {
-  try {
-    const content = readFileSync2(path, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-function writePackageJson(path, pkg) {
-  writeFileSync(path, JSON.stringify(pkg, null, "\t") + `
-`, "utf-8");
-}
-function getWorkspaceAccountId() {
-  const pkgPath = findPackageJsonPath();
-  if (!pkgPath)
-    return null;
-  const pkg = readPackageJson(pkgPath);
-  return pkg?.devflare?.accountId ?? null;
-}
-function setWorkspaceAccountId(accountId) {
-  let pkgPath = findPackageJsonPath();
-  let pkg;
-  if (pkgPath) {
-    pkg = readPackageJson(pkgPath) ?? {};
-  } else {
-    pkgPath = join2(process.cwd(), "package.json");
-    pkg = {
-      name: "workspace",
-      private: true
-    };
-  }
-  if (!pkg.devflare) {
-    pkg.devflare = {};
-  }
-  pkg.devflare.accountId = accountId;
-  writePackageJson(pkgPath, pkg);
-  return pkgPath;
-}
-async function getOrCreatePreferencesNamespace(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;
-}
-async function getGlobalDefaultAccountId(fallbackAccountId) {
-  const local = readLocalPreferences();
-  if (local.defaultAccountId) {
-    return local.defaultAccountId;
-  }
-  try {
-    const namespaceId = await getOrCreatePreferencesNamespace(fallbackAccountId);
-    const value = await kvGet(fallbackAccountId, namespaceId, GLOBAL_ACCOUNT_KEY);
-    if (value) {
-      writeLocalPreferences({
-        ...local,
-        defaultAccountId: value,
-        lastUpdated: new Date().toISOString()
-      });
-      return value;
-    }
-  } catch {}
-  return null;
-}
-async function setGlobalDefaultAccountId(accountId, anyAccountId) {
-  const kvAccountId = anyAccountId ?? accountId;
-  const local = readLocalPreferences();
-  writeLocalPreferences({
-    ...local,
-    defaultAccountId: accountId,
-    lastUpdated: new Date().toISOString()
-  });
-  try {
-    const namespaceId = await getOrCreatePreferencesNamespace(kvAccountId);
-    await kvPut(kvAccountId, namespaceId, GLOBAL_ACCOUNT_KEY, accountId);
-  } catch {}
-}
-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" };
-}
-async function clearGlobalDefaultAccountId(anyAccountId) {
-  const local = readLocalPreferences();
-  delete local.defaultAccountId;
-  local.lastUpdated = new Date().toISOString();
-  writeLocalPreferences(local);
-  try {
-    const namespaceId = await getOrCreatePreferencesNamespace(anyAccountId);
-    await kvPut(anyAccountId, namespaceId, GLOBAL_ACCOUNT_KEY, "");
-  } 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 };