nolo-cli 0.9.1 → 0.11.0

package/{chunk-COMXDWNM.js → chunk-O26GI2JP.js}

@@ -5,17 +5,17 @@ import {
   loadFileFromIndexedDb,
   removeAction,
   saveFileToIndexedDb
-} from "./chunk-2EISRLRC.js";
+} from "./chunk-IPYUUY4E.js";
 import {
   fileKey,
   getFileIdFromKey,
   ulid
-} from "./chunk-SH2CFQOH.js";
+} from "./chunk-O4BU24WZ.js";
 import {
   readAction,
   readRequestManager,
   resolveAgentReadServers
-} from "./chunk-ELRRLDWI.js";
+} from "./chunk-XFOLQLDN.js";
 import {
   asyncThunkCreator,
   buildCreateSlice,
@@ -35,22 +35,22 @@ import {
   shouldReplaceLocalWithRemoteRecord,
   shouldReplicateLocalRecord,
   uploadToCurrentServer
-} from "./chunk-EYEEHCU4.js";
+} from "./chunk-OOM6SJNR.js";
 import {
   fetchFromClientDb,
   fetchFromServer,
   logger,
   normalizeTimeFields
-} from "./chunk-QYXLLLGL.js";
+} from "./chunk-OOSFSFMA.js";
 import {
   isTombstoneRecord
 } from "./chunk-GBRG75BQ.js";
-import {
-  API_ENDPOINTS
-} from "./chunk-LCBAMY2M.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
+import {
+  API_ENDPOINTS
+} from "./chunk-LCBAMY2M.js";
 
 // packages/database/actions/readAndWait.ts
 var hashTokenScope = (currentToken) => {
@@ -674,7 +674,7 @@ var dbSlice = createSliceWithThunks({
     // 动态 import 在调用期解析，避开 TDZ/求值顺序问题（同下方 share）。
     read: create.asyncThunk(
       async (payload, thunkApi) => {
-        const { readAction: readAction2 } = await import("./read-RIJCIVKX.js");
+        const { readAction: readAction2 } = await import("./read-QJNKRROM.js");
         return readAction2(payload, thunkApi);
       },
       {
@@ -748,7 +748,7 @@ var dbSlice = createSliceWithThunks({
     // 这里改成动态 import，运行期才解析，彻底断开这条边。
     share: create.asyncThunk(
       async (config, thunkApi) => {
-        const { shareResourceAction } = await import("./action-ZJWE3Y5S.js");
+        const { shareResourceAction } = await import("./action-AA4IJ5K2.js");
         return shareResourceAction(config, thunkApi);
       }
     ),

package/{chunk-SH2CFQOH.js → chunk-O4BU24WZ.js}

@@ -12,187 +12,9 @@ import {
 } from "./chunk-G3SUCT4W.js";
 import {
   __commonJS,
-  __require,
   __toESM
 } from "./chunk-4VNS5WPM.js";
 
-// node_modules/ulid/dist/index.umd.js
-var require_index_umd = __commonJS({
-  "node_modules/ulid/dist/index.umd.js"(exports, module) {
-    (function(global, factory) {
-      typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : factory(global.ULID = {});
-    })(exports, function(exports2) {
-      "use strict";
-      function createError(message) {
-        var err = new Error(message);
-        err.source = "ulid";
-        return err;
-      }
-      var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-      var ENCODING_LEN = ENCODING.length;
-      var TIME_MAX = Math.pow(2, 48) - 1;
-      var TIME_LEN = 10;
-      var RANDOM_LEN = 16;
-      function replaceCharAt(str, index, char) {
-        if (index > str.length - 1) {
-          return str;
-        }
-        return str.substr(0, index) + char + str.substr(index + 1);
-      }
-      function incrementBase32(str) {
-        var done = void 0;
-        var index = str.length;
-        var char = void 0;
-        var charIndex = void 0;
-        var maxCharIndex = ENCODING_LEN - 1;
-        while (!done && index-- >= 0) {
-          char = str[index];
-          charIndex = ENCODING.indexOf(char);
-          if (charIndex === -1) {
-            throw createError("incorrectly encoded string");
-          }
-          if (charIndex === maxCharIndex) {
-            str = replaceCharAt(str, index, ENCODING[0]);
-            continue;
-          }
-          done = replaceCharAt(str, index, ENCODING[charIndex + 1]);
-        }
-        if (typeof done === "string") {
-          return done;
-        }
-        throw createError("cannot increment this string");
-      }
-      function randomChar(prng2) {
-        var rand = Math.floor(prng2() * ENCODING_LEN);
-        if (rand === ENCODING_LEN) {
-          rand = ENCODING_LEN - 1;
-        }
-        return ENCODING.charAt(rand);
-      }
-      function encodeTime(now, len) {
-        if (isNaN(now)) {
-          throw new Error(now + " must be a number");
-        }
-        if (now > TIME_MAX) {
-          throw createError("cannot encode time greater than " + TIME_MAX);
-        }
-        if (now < 0) {
-          throw createError("time must be positive");
-        }
-        if (Number.isInteger(now) === false) {
-          throw createError("time must be an integer");
-        }
-        var mod = void 0;
-        var str = "";
-        for (; len > 0; len--) {
-          mod = now % ENCODING_LEN;
-          str = ENCODING.charAt(mod) + str;
-          now = (now - mod) / ENCODING_LEN;
-        }
-        return str;
-      }
-      function encodeRandom(len, prng2) {
-        var str = "";
-        for (; len > 0; len--) {
-          str = randomChar(prng2) + str;
-        }
-        return str;
-      }
-      function decodeTime(id) {
-        if (id.length !== TIME_LEN + RANDOM_LEN) {
-          throw createError("malformed ulid");
-        }
-        var time = id.substr(0, TIME_LEN).split("").reverse().reduce(function(carry, char, index) {
-          var encodingIndex = ENCODING.indexOf(char);
-          if (encodingIndex === -1) {
-            throw createError("invalid character found: " + char);
-          }
-          return carry += encodingIndex * Math.pow(ENCODING_LEN, index);
-        }, 0);
-        if (time > TIME_MAX) {
-          throw createError("malformed ulid, timestamp too large");
-        }
-        return time;
-      }
-      function detectPrng() {
-        var allowInsecure = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
-        var root = arguments[1];
-        if (!root) {
-          root = typeof window !== "undefined" ? window : null;
-        }
-        var browserCrypto = root && (root.crypto || root.msCrypto);
-        if (browserCrypto) {
-          return function() {
-            var buffer = new Uint8Array(1);
-            browserCrypto.getRandomValues(buffer);
-            return buffer[0] / 255;
-          };
-        } else {
-          try {
-            var nodeCrypto = __require("crypto");
-            return function() {
-              return nodeCrypto.randomBytes(1).readUInt8() / 255;
-            };
-          } catch (e) {
-          }
-        }
-        if (allowInsecure) {
-          try {
-            console.error("secure crypto unusable, falling back to insecure Math.random()!");
-          } catch (e) {
-          }
-          return function() {
-            return Math.random();
-          };
-        }
-        throw createError("secure crypto unusable, insecure Math.random not allowed");
-      }
-      function factory(currPrng) {
-        if (!currPrng) {
-          currPrng = detectPrng();
-        }
-        return function ulid3(seedTime) {
-          if (isNaN(seedTime)) {
-            seedTime = Date.now();
-          }
-          return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN, currPrng);
-        };
-      }
-      function monotonicFactory2(currPrng) {
-        if (!currPrng) {
-          currPrng = detectPrng();
-        }
-        var lastTime = 0;
-        var lastRandom = void 0;
-        return function ulid3(seedTime) {
-          if (isNaN(seedTime)) {
-            seedTime = Date.now();
-          }
-          if (seedTime <= lastTime) {
-            var incrementedRandom = lastRandom = incrementBase32(lastRandom);
-            return encodeTime(lastTime, TIME_LEN) + incrementedRandom;
-          }
-          lastTime = seedTime;
-          var newRandom = lastRandom = encodeRandom(RANDOM_LEN, currPrng);
-          return encodeTime(seedTime, TIME_LEN) + newRandom;
-        };
-      }
-      var ulid2 = factory();
-      exports2.replaceCharAt = replaceCharAt;
-      exports2.incrementBase32 = incrementBase32;
-      exports2.randomChar = randomChar;
-      exports2.encodeTime = encodeTime;
-      exports2.encodeRandom = encodeRandom;
-      exports2.decodeTime = decodeTime;
-      exports2.detectPrng = detectPrng;
-      exports2.factory = factory;
-      exports2.monotonicFactory = monotonicFactory2;
-      exports2.ulid = ulid2;
-      Object.defineProperty(exports2, "__esModule", { value: true });
-    });
-  }
-});
-
 // node_modules/rambda/dist/rambda.js
 var require_rambda = __commonJS({
   "node_modules/rambda/dist/rambda.js"(exports) {
@@ -2577,9 +2399,9 @@ function toTrimmedString(value) {
 }
 
 // packages/database/utils/ulid.ts
-var import_ulid = __toESM(require_index_umd(), 1);
+import { monotonicFactory } from "ulid";
 var prng = () => Math.random();
-var ulid = (0, import_ulid.monotonicFactory)(prng);
+var ulid = monotonicFactory(prng);
 
 // packages/database/keys.ts
 var import_rambda = __toESM(require_rambda(), 1);
@@ -3343,7 +3165,6 @@ var sanitizeShareData = (data) => {
 };
 
 export {
-  require_index_umd,
   ulid,
   toTrimmedString,
   toNonEmptyString,

package/{chunk-EYEEHCU4.js → chunk-OOM6SJNR.js}

@@ -2,7 +2,16 @@ import {
   getAllServers,
   getIsDesktopApp,
   isAbortError
-} from "./chunk-QYXLLLGL.js";
+} from "./chunk-OOSFSFMA.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
+import {
+  asOptionalPositiveFiniteNumber
+} from "./chunk-U6VC4MU4.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
 import {
   isLocalServerUrl
 } from "./chunk-4SN6J65J.js";
@@ -11,21 +20,12 @@ import {
   SERVERS,
   normalizeKnownServerOrigin
 } from "./chunk-LCBAMY2M.js";
-import {
-  asTrimmedString
-} from "./chunk-3EUW3WEO.js";
-import {
-  asOptionalPositiveFiniteNumber
-} from "./chunk-U6VC4MU4.js";
 import {
   normalizeServerOrigin
 } from "./chunk-CF7PE763.js";
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
-import {
-  isRecord
-} from "./chunk-KUG52IAP.js";
 
 // node_modules/reselect/dist/reselect.mjs
 var runIdentityFunctionCheck = (resultFunc, inputSelectorsResults, outputSelectorResult) => {

package/chunk-OOSFSFMA.js

@@ -0,0 +1,271 @@
+import {
+  API_ENDPOINTS,
+  NOLO_CLUSTER_SERVERS,
+  isLocalDevServerOrigin,
+  isNoloClusterServerOrigin,
+  normalizeKnownServerOrigin
+} from "./chunk-LCBAMY2M.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+
+// packages/app/utils/env.ts
+var processEnv = typeof process !== "undefined" ? process.env : void 0;
+var reactNativeDev = typeof globalThis !== "undefined" && "__DEV__" in globalThis ? globalThis.__DEV__ : void 0;
+var isProduction = processEnv?.NOLO_FORCE_PRODUCTION === "1" || processEnv?.NODE_ENV === "production" || reactNativeDev === false;
+var getIsDesktopApp = () => (typeof process !== "undefined" ? process.env?.NOLO_DESKTOP : processEnv?.NOLO_DESKTOP) === "1" || typeof window !== "undefined" && window.__NOLO_DESKTOP__ === true;
+var isDesktopApp = getIsDesktopApp();
+
+// packages/core/abortError.ts
+function isAbortError(error) {
+  if (!error || typeof error !== "object") return false;
+  return error.name === "AbortError";
+}
+
+// packages/core/clientLogger.ts
+var LOG_LEVELS = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+var serializeValue = (value, seen = /* @__PURE__ */ new WeakSet()) => {
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+      ...value.stack ? { stack: value.stack } : {}
+    };
+  }
+  if (typeof value !== "object" || value === null) {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    return value;
+  }
+  if (seen.has(value)) {
+    return "[Circular]";
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => serializeValue(item, seen));
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => [key, serializeValue(item, seen)])
+  );
+};
+var getLogLevel = () => {
+  const configured = typeof process !== "undefined" && typeof process.env?.NOLO_LOG_LEVEL === "string" ? process.env.NOLO_LOG_LEVEL : "info";
+  return LOG_LEVELS[configured] ?? LOG_LEVELS.info;
+};
+var writeLog = (level, name, fields, message) => {
+  if (LOG_LEVELS[level] < getLogLevel()) {
+    return;
+  }
+  const serializedFields = serializeValue(fields);
+  const payload = {
+    level,
+    ...name ? { name } : {},
+    ...serializedFields,
+    ...message ? { msg: message } : {}
+  };
+  const output = JSON.stringify(payload);
+  const isNodeRuntime = typeof process !== "undefined" && typeof process.stderr?.write === "function";
+  if (isNodeRuntime) {
+    process.stderr.write(`${output}
+`);
+    return;
+  }
+  const consoleMethod = console[level] ?? console.log;
+  if (Object.keys(fields).length === 0 && message) {
+    consoleMethod(`[${name}] ${message}`);
+  } else {
+    consoleMethod(output);
+  }
+};
+var parseArgs = (first, second) => {
+  if (typeof first === "string") {
+    return { fields: {}, message: first };
+  }
+  return { fields: first ?? {}, message: second };
+};
+var createClientLogger = (name, parentFields = {}) => {
+  const log = (level, first, second) => {
+    const { fields, message } = parseArgs(first, second);
+    writeLog(level, name, { ...parentFields, ...fields }, message);
+  };
+  return {
+    debug: (first, second) => log("debug", first, second),
+    info: (first, second) => log("info", first, second),
+    warn: (first, second) => log("warn", first, second),
+    error: (first, second) => log("error", first, second),
+    child: (fields) => createClientLogger(name, { ...parentFields, ...fields })
+  };
+};
+
+// packages/app/utils/retryFetch.ts
+var TRANSIENT_READ_RETRY_STATUSES = /* @__PURE__ */ new Set([502, 503, 504]);
+var DEFAULT_RETRY_DELAYS_MS = [300, 1e3];
+var sleep = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+var getRequestMethod = (input, init) => {
+  if (init?.method) return init.method.toUpperCase();
+  if (typeof Request !== "undefined" && input instanceof Request) {
+    return input.method.toUpperCase();
+  }
+  return "GET";
+};
+var isRetryableReadMethod = (method) => method === "GET" || method === "HEAD";
+var fetchWithTransientReadRetry = async (input, init, options = {}) => {
+  const method = getRequestMethod(input, init);
+  const canRetry = isRetryableReadMethod(method);
+  const delaysMs = options.delaysMs ?? DEFAULT_RETRY_DELAYS_MS;
+  const retryStatuses = options.retryStatuses ?? TRANSIENT_READ_RETRY_STATUSES;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const wait = options.sleep ?? sleep;
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      const response = await fetchImpl(input, init);
+      const shouldRetry = canRetry && retryStatuses.has(response.status) && attempt < delaysMs.length;
+      if (!shouldRetry) return response;
+    } catch (error) {
+      const shouldRetry = canRetry && !isAbortError(error) && attempt < delaysMs.length;
+      if (!shouldRetry) throw error;
+    }
+    await wait(delaysMs[attempt]);
+  }
+};
+
+// packages/database/levelNotFoundError.ts
+function isLevelNotFoundError(error) {
+  if (!error || typeof error !== "object") return false;
+  const e = error;
+  return e.notFound === true || e.name === "NotFoundError" || e.code === "LEVEL_NOT_FOUND" || e.code === "LEVEL_NOT_FOUND_ERROR" || e.message === "NotFound";
+}
+
+// packages/database/actions/common.ts
+var logger = createClientLogger("database");
+var normalizeServer = (server) => normalizeKnownServerOrigin(server) ?? normalizeServerOrigin(server);
+var mergeConfiguredServers = (currentServer, syncServers) => {
+  const runtimeOrigin = !getIsDesktopApp() && typeof window !== "undefined" && typeof window.location?.origin === "string" && /^https?:\/\//.test(window.location.origin) ? window.location.origin : void 0;
+  const raw = [
+    currentServer,
+    ...Array.isArray(syncServers) ? syncServers : [],
+    runtimeOrigin
+  ].filter(
+    (s) => typeof s === "string" && s.trim().length > 0
+  );
+  const normalized = raw.map(normalizeServer);
+  const shouldIncludeClusterPeers = normalized.some(isNoloClusterServerOrigin) || typeof currentServer === "string" && isLocalDevServerOrigin(currentServer);
+  if (shouldIncludeClusterPeers) {
+    normalized.push(...NOLO_CLUSTER_SERVERS);
+  }
+  return Array.from(new Set(normalized));
+};
+var getAllServers = (currentServer, syncServers, preferredServer) => {
+  const preferredNormalized = typeof preferredServer === "string" && preferredServer.trim().length > 0 ? normalizeServer(preferredServer) : null;
+  const servers = mergeConfiguredServers(
+    currentServer,
+    preferredNormalized && isNoloClusterServerOrigin(preferredNormalized) ? [...Array.isArray(syncServers) ? syncServers : [], preferredNormalized] : syncServers
+  );
+  if (!preferredServer || typeof preferredServer !== "string") {
+    return servers;
+  }
+  const remaining = servers.filter(
+    (server) => normalizeServer(server) !== preferredNormalized
+  );
+  return preferredNormalized ? [preferredNormalized, ...remaining] : remaining;
+};
+var fetchFromClientDb = async (clientDb, dbKey) => {
+  if (!clientDb) {
+    logger.error(
+      { dbKey },
+      "Client database is undefined in fetchFromClientDb"
+    );
+    return null;
+  }
+  try {
+    return await clientDb.get(dbKey);
+  } catch (err) {
+    if (isLevelNotFoundError(err)) {
+      return null;
+    }
+    logger.error({ err, dbKey }, "Failed to get local data");
+    return null;
+  }
+};
+var SERVER_TIMEOUT = 5e3;
+var READ_TIMEOUT_ERROR_NAME = "ReadTimeoutError";
+var isPublicFileDbKey = (dbKey) => dbKey.startsWith("file-");
+var buildReadUrl = (dbKey) => isPublicFileDbKey(dbKey) ? `${API_ENDPOINTS.DATABASE}/file/metadata/${encodeURIComponent(dbKey)}` : `${API_ENDPOINTS.DATABASE}/read/${encodeURIComponent(dbKey)}`;
+var createReadTimeoutError = (server, dbKey) => {
+  const error = new Error(
+    `Timed out reading key "${dbKey}" from ${normalizeServer(server)}.`
+  );
+  error.name = READ_TIMEOUT_ERROR_NAME;
+  return error;
+};
+var isReadTimeoutError = (error) => error instanceof Error && error.name === READ_TIMEOUT_ERROR_NAME;
+var fetchFromServer = async (server, dbKey, token, signal) => {
+  if (signal?.aborted) {
+    throw new DOMException("Aborted", "AbortError");
+  }
+  const controller = new AbortController();
+  let didTimeout = false;
+  const timeoutId = setTimeout(() => {
+    didTimeout = true;
+    controller.abort();
+  }, SERVER_TIMEOUT);
+  const onExternalAbort = () => controller.abort();
+  signal?.addEventListener("abort", onExternalAbort);
+  try {
+    const res = await fetchWithTransientReadRetry(
+      `${server}${buildReadUrl(dbKey)}`,
+      {
+        signal: controller.signal,
+        headers: {
+          "Content-Type": "application/json",
+          ...token && { Authorization: `Bearer ${token}` }
+        }
+      }
+    );
+    clearTimeout(timeoutId);
+    signal?.removeEventListener("abort", onExternalAbort);
+    if (res.status === 200) {
+      return await res.json();
+    }
+    return null;
+  } catch (err) {
+    clearTimeout(timeoutId);
+    signal?.removeEventListener("abort", onExternalAbort);
+    if (didTimeout) {
+      throw createReadTimeoutError(server, dbKey);
+    }
+    if (signal?.aborted || isAbortError(err)) {
+      throw err;
+    }
+    return null;
+  }
+};
+var normalizeTimeFields = (data) => ({
+  ...data,
+  createdAt: data.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+  updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+  updated_at: void 0,
+  created_at: void 0
+});
+
+export {
+  isProduction,
+  getIsDesktopApp,
+  createClientLogger,
+  isAbortError,
+  fetchWithTransientReadRetry,
+  logger,
+  getAllServers,
+  fetchFromClientDb,
+  isReadTimeoutError,
+  fetchFromServer,
+  normalizeTimeFields
+};

package/{chunk-PAKN26FP.js → chunk-OUI3ZHYD.js}

@@ -1,6 +1,6 @@
 import {
   canonicalizeToolNames
-} from "./chunk-AUQ747NZ.js";
+} from "./chunk-4SOKXIW4.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";

package/{chunk-EXTIQUCI.js → chunk-PNEW2Z3T.js}

@@ -9,6 +9,15 @@ import {
   loadProfileConfig,
   saveDefaultProfile
 } from "./chunk-ROWQEJRP.js";
+import {
+  createMemoryKey,
+  createMemoryOwnerIndexKey,
+  createMemorySubjectKindIndexKey,
+  memoryOwnerRange
+} from "./chunk-O4BU24WZ.js";
+import {
+  asTrimmedNonEmptyStringArray
+} from "./chunk-I42VC5KR.js";
 import {
   resolveAuthTokenFromEnv
 } from "./chunk-ISNCLGUZ.js";
@@ -18,15 +27,6 @@ import {
 import {
   getDefaultCliLocalRuntimeDb
 } from "./chunk-H33743XH.js";
-import {
-  createMemoryKey,
-  createMemoryOwnerIndexKey,
-  createMemorySubjectKindIndexKey,
-  memoryOwnerRange
-} from "./chunk-SH2CFQOH.js";
-import {
-  asTrimmedNonEmptyStringArray
-} from "./chunk-I42VC5KR.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";

package/{chunk-CPB2YM4D.js → chunk-PXQN7IBQ.js}

@@ -1,10 +1,10 @@
 import {
   i18n_default,
   toolRegistry
-} from "./chunk-MKMWT7SA.js";
+} from "./chunk-2W2VYVI5.js";
 import {
   canonicalizeToolNames
-} from "./chunk-AUQ747NZ.js";
+} from "./chunk-4SOKXIW4.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";

package/{chunk-4IJYA27C.js → chunk-PXZAAB4L.js}

@@ -1,13 +1,13 @@
 import {
   generatePkcePair,
   startCallbackServer
-} from "./chunk-EHLHSX7R.js";
-import {
-  toErrorMessage
-} from "./chunk-HNMXYYJR.js";
+} from "./chunk-5MMZUWSG.js";
 import {
   asOptionalFiniteNumber
 } from "./chunk-WWC7I6TA.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
 
 // packages/cli/oauth/flows/cloudflare.ts
 var CLOUDFLARE_OAUTH_AUTH_ENDPOINT = "https://dash.cloudflare.com/oauth2/auth";