devflare 1.0.0-next.39 → 1.0.0-next.40

package/dist/index-04wh9bxx.js

@@ -1,514 +0,0 @@
-// src/cloudflare/auth.ts
-import { execSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { parse as parseToml } from "smol-toml";
-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) {
-  let parsed;
-  try {
-    parsed = parseToml(content);
-  } catch {
-    return {};
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(parsed)) {
-    if (typeof value === "string") {
-      result[key] = value;
-    } else if (typeof value === "number" || typeof value === "boolean") {
-      result[key] = String(value);
-    }
-  }
-  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;
-
-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 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);
-    }
-  }
-}
-function tryParseJson(text) {
-  if (text.length === 0)
-    return { ok: false };
-  try {
-    return { ok: true, value: JSON.parse(text) };
-  } catch {
-    return { ok: false };
-  }
-}
-function isEnvelopeShape(value) {
-  if (!value || typeof value !== "object")
-    return false;
-  const record = value;
-  return typeof record.success === "boolean" && Array.isArray(record.errors) && Array.isArray(record.messages) && "result" in record;
-}
-function coerceBareResultEnvelope(value, response) {
-  if (!response.ok)
-    return null;
-  if (!value || typeof value !== "object")
-    return null;
-  const record = value;
-  if (!("result" in record))
-    return null;
-  return {
-    success: true,
-    errors: [],
-    messages: [],
-    result: record.result,
-    ...record.result_info && typeof record.result_info === "object" ? { result_info: record.result_info } : {}
-  };
-}
-function envelopeFailureError(response, envelope, endpoint) {
-  const first = envelope.errors[0];
-  const message = first ? `Cloudflare ${endpoint} failed (${first.code}): ${first.message}` : `Cloudflare ${endpoint} failed`;
-  return new CloudflareAPIError(message, response.status, envelope.errors);
-}
-async function decodeCloudflareEnvelope(response, opts) {
-  if (opts.allow404 === true && response.status === 404) {
-    return null;
-  }
-  const text = await response.text();
-  const parsed = tryParseJson(text);
-  if (!parsed.ok) {
-    throw new CloudflareAPIError(`Cloudflare API returned an invalid JSON response. Body: ${truncateBody(text)}`, response.status, []);
-  }
-  if (!isEnvelopeShape(parsed.value)) {
-    const coerced = coerceBareResultEnvelope(parsed.value, response);
-    if (coerced) {
-      return coerced;
-    }
-    throw new CloudflareAPIError(`Cloudflare ${opts.endpoint} returned a non-envelope JSON response. Body: ${truncateBody(text)}`, response.status, []);
-  }
-  return parsed.value;
-}
-function truncateBody(text, max = 500) {
-  const trimmed = text.trim();
-  if (trimmed.length <= max)
-    return trimmed;
-  return `${trimmed.slice(0, max)}…[truncated, total ${trimmed.length} chars]`;
-}
-async function parseCloudflareEnvelope(response, opts) {
-  const envelope = await decodeCloudflareEnvelope(response, opts);
-  if (envelope === null) {
-    return null;
-  }
-  if (!envelope.success) {
-    throw envelopeFailureError(response, envelope, opts.endpoint);
-  }
-  return envelope.result;
-}
-async function parseRawJson(response, opts) {
-  const text = await response.text();
-  const parsed = tryParseJson(text);
-  if (!parsed.ok) {
-    throw new CloudflareAPIError(`Cloudflare ${opts.endpoint} returned an invalid JSON response.`, response.status, []);
-  }
-  return parsed.value;
-}
-function createCloudflareAuthSession(opts = {}) {
-  const provider = opts.tokenProvider ?? ((forceRefresh) => getApiToken(forceRefresh));
-  const onInvalidate = opts.onInvalidate ?? invalidateToken;
-  return {
-    async getAuthHeader(forceRefresh = false) {
-      const token = await provider(forceRefresh);
-      if (!token) {
-        throw new AuthenticationError;
-      }
-      return `Bearer ${token}`;
-    },
-    invalidate() {
-      onInvalidate();
-    }
-  };
-}
-var defaultAuthSession = createCloudflareAuthSession({});
-async function resolveAuthHeader(options, forceRefresh = false) {
-  if (options?.token) {
-    return `Bearer ${options.token}`;
-  }
-  return defaultAuthSession.getAuthHeader(forceRefresh);
-}
-function isAuthError(response, envelope) {
-  if (response.status === 401)
-    return true;
-  if (!envelope.success && envelope.errors?.some((e) => e.code === 1e4 || e.message?.toLowerCase().includes("authentication") || e.message?.toLowerCase().includes("token"))) {
-    return true;
-  }
-  return false;
-}
-var RETRYABLE_STATUS = new Set([408, 425, 429, 500, 502, 503, 504]);
-var RETRY_BASE_DELAY_MS = 250;
-var RETRY_MAX_ATTEMPTS = 4;
-function shouldRetryResponse(response) {
-  return RETRYABLE_STATUS.has(response.status);
-}
-function backoffDelayMs(attempt, retryAfterHeader) {
-  if (retryAfterHeader) {
-    const parsed = Number(retryAfterHeader);
-    if (Number.isFinite(parsed) && parsed > 0) {
-      return Math.min(parsed * 1000, 1e4);
-    }
-  }
-  const base = RETRY_BASE_DELAY_MS * 2 ** attempt;
-  const jitter = Math.random() * RETRY_BASE_DELAY_MS;
-  return Math.min(base + jitter, 1e4);
-}
-async function requestCloudflareJson(path, request, options) {
-  const endpoint = `${request.method} ${path}`;
-  const makeRequest = async (forceRefresh) => {
-    const authorization = await resolveAuthHeader(options, forceRefresh);
-    const headers = new Headers({
-      Authorization: authorization,
-      "Content-Type": "application/json"
-    });
-    const response = await fetchWithTimeout(`${API_BASE}${path}`, {
-      method: request.method,
-      headers,
-      ...request.body !== undefined ? { body: JSON.stringify(request.body) } : {}
-    }, options?.timeout ?? DEFAULT_TIMEOUT);
-    const envelope = await decodeCloudflareEnvelope(response, { endpoint });
-    return { response, envelope };
-  };
-  let result = null;
-  let lastError = null;
-  for (let attempt = 0;attempt < RETRY_MAX_ATTEMPTS; attempt++) {
-    try {
-      result = await makeRequest(false);
-    } catch (error) {
-      lastError = error;
-      if (attempt < RETRY_MAX_ATTEMPTS - 1) {
-        await new Promise((r) => setTimeout(r, backoffDelayMs(attempt, null)));
-        continue;
-      }
-      throw error;
-    }
-    const current = result;
-    if (!shouldRetryResponse(current.response) || attempt === RETRY_MAX_ATTEMPTS - 1) {
-      break;
-    }
-    await new Promise((r) => setTimeout(r, backoffDelayMs(attempt, current.response.headers.get("retry-after"))));
-  }
-  if (!result) {
-    throw lastError ?? new Error(`Cloudflare API request failed: ${endpoint}`);
-  }
-  if (request.allowAuthRetry === true && isAuthError(result.response, result.envelope) && !options?.token) {
-    defaultAuthSession.invalidate();
-    result = await makeRequest(true);
-  }
-  return result;
-}
-async function requestCloudflareResult(path, request, options) {
-  const { response, envelope } = await requestCloudflareJson(path, request, options);
-  if (!envelope.success) {
-    throw envelopeFailureError(response, envelope, `${request.method} ${path}`);
-  }
-  return envelope.result;
-}
-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);
-}
-var DEFAULT_PAGINATION_MAX_PAGES = 500;
-var DEFAULT_PAGINATION_PAGE_SIZE = 50;
-async function apiGetAll(path, options) {
-  const results = [];
-  let page = 1;
-  let cursor;
-  const perPage = options?.pageSize ?? DEFAULT_PAGINATION_PAGE_SIZE;
-  const maxPages = options?.maxPages ?? DEFAULT_PAGINATION_MAX_PAGES;
-  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, envelope } = await requestCloudflareJson(pagedPath, {
-      method: "GET",
-      allowAuthRetry: true
-    }, options);
-    if (!envelope.success) {
-      throw envelopeFailureError(response, envelope, `GET ${pagedPath}`);
-    }
-    const pageResults = extractPaginatedItems(envelope.result);
-    results.push(...pageResults);
-    if (!envelope.result_info) {
-      break;
-    }
-    if (pageResults.length === 0) {
-      break;
-    }
-    const nextCursor = envelope.result_info.cursor?.trim();
-    if (nextCursor) {
-      if (seenCursors.has(nextCursor)) {
-        break;
-      }
-      seenCursors.add(nextCursor);
-      cursor = nextCursor;
-      continue;
-    }
-    if (cursor) {
-      break;
-    }
-    if (envelope.result_info.total_count !== undefined) {
-      if (results.length >= envelope.result_info.total_count) {
-        break;
-      }
-    }
-    if (envelope.result_info.total_pages !== undefined) {
-      if (page >= envelope.result_info.total_pages) {
-        break;
-      }
-    }
-    page++;
-  }
-  if (page > maxPages) {
-    const lastPageLikelyFull = results.length % perPage === 0 && results.length > 0;
-    if (lastPageLikelyFull) {
-      console.warn(`[devflare] apiGetAll capped at ${maxPages} pages for ${path}. Results may be truncated; pass { maxPages } to raise the cap.`);
-    }
-  }
-  return results;
-}
-async function requestKVValue(accountId, namespaceId, key, request, options) {
-  const authorization = await resolveAuthHeader(options);
-  const encodedKey = encodeURIComponent(key);
-  const url = `${API_BASE}/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${encodedKey}`;
-  return fetchWithTimeout(url, {
-    method: request.method,
-    headers: {
-      Authorization: authorization,
-      ...request.method === "PUT" ? { "Content-Type": "text/plain" } : {}
-    },
-    ...request.method === "PUT" ? { body: request.value } : {}
-  }, options?.timeout ?? DEFAULT_TIMEOUT);
-}
-async function throwKVValueError(response, endpoint) {
-  await parseCloudflareEnvelope(response, { endpoint });
-  throw new CloudflareAPIError(`Cloudflare ${endpoint} failed`, response.status, []);
-}
-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 throwKVValueError(response, "KV read");
-  }
-  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 throwKVValueError(response, "KV write");
-  }
-}
-async function kvDelete(accountId, namespaceId, key, options) {
-  const response = await requestKVValue(accountId, namespaceId, key, {
-    method: "DELETE"
-  }, options);
-  if (response.status === 404) {
-    return;
-  }
-  if (!response.ok) {
-    await throwKVValueError(response, "KV delete");
-  }
-}
-
-export { hasWranglerConfig, getWranglerAuth, getApiToken, isAuthenticated, CloudflareAPIError, AuthenticationError, parseCloudflareEnvelope, parseRawJson, createCloudflareAuthSession, apiGet, apiPost, apiPut, apiPatch, apiDelete, apiGetAll, kvGet, kvPut, kvDelete };

package/dist/index-0cc05hzv.js

@@ -1,74 +0,0 @@
-import {
-  loadConfig,
-  resolveConfigPath
-} from "./index-x8s9rwfh.js";
-import {
-  getEffectiveAccountId,
-  getPrimaryAccount,
-  getWorkspaceAccountId
-} from "./index-h7r11y4a.js";
-
-// src/cli/command-utils.ts
-function asOptionalString(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-function resolveNamedSelection(options) {
-  if (options.explicitValue) {
-    return {
-      value: options.explicitValue,
-      source: "option"
-    };
-  }
-  if (options.fallbackValue) {
-    return {
-      value: options.fallbackValue,
-      source: "arg"
-    };
-  }
-  if (options.configuredValue) {
-    return {
-      value: options.configuredValue,
-      source: "config"
-    };
-  }
-  return {
-    value: undefined,
-    source: "none"
-  };
-}
-async function getConfiguredAccountId(cwd) {
-  const workspaceAccountId = getWorkspaceAccountId();
-  if (workspaceAccountId) {
-    return workspaceAccountId;
-  }
-  const envAccountId = process.env.CLOUDFLARE_ACCOUNT_ID?.trim();
-  if (envAccountId) {
-    return envAccountId;
-  }
-  const configPath = await resolveConfigPath(cwd);
-  if (!configPath) {
-    return;
-  }
-  try {
-    const config = await loadConfig({ cwd });
-    return config.accountId;
-  } catch {
-    return;
-  }
-}
-async function resolveCloudflareAccountId(options) {
-  if (options.explicitAccountId) {
-    return options.explicitAccountId;
-  }
-  if (options.configuredAccountId) {
-    return options.configuredAccountId;
-  }
-  const primaryAccount = await getPrimaryAccount(options.apiOptions);
-  if (!primaryAccount) {
-    return;
-  }
-  const effective = await getEffectiveAccountId(primaryAccount.id);
-  return effective.accountId;
-}
-
-export { asOptionalString, resolveNamedSelection, getConfiguredAccountId, resolveCloudflareAccountId };