@lvce-editor/auth-worker 3.22.0 → 3.22.2

package/dist/authWorkerMain.js

@@ -1135,18 +1135,17 @@ const {
 const {
   invoke,
   invokeAndTransfer} = create(RendererWorker);
-const sendMessagePortToOpenerWorker$1 = async (port, rpcId) => {
+const sendMessagePortToOpenerWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToOpenerWorker', port, command, rpcId);
 };
-
-const sendMessagePortToOpenerWorker = async port => {
-  await sendMessagePortToOpenerWorker$1(port, 0);
+const send = async (port, sourceId = 0) => {
+  await sendMessagePortToOpenerWorker(port, sourceId);
 };
 const initializeOpenerWorker = async () => {
   const rpc = await create$2({
     commandMap: {},
-    send: sendMessagePortToOpenerWorker
+    send
   });
   set(rpc);
 };
@@ -1242,14 +1241,11 @@ const createAccountSessions = storage => {
   };
 };
 
-const state$4 = {
-  backendUrl: ''
-};
-const getAuthBackendUrl = () => {
-  return state$4.backendUrl;
-};
-const setAuthBackendUrl = backendUrl => {
-  state$4.backendUrl = backendUrl;
+const getAuthBackendUrl = async backendUrl => {
+  if (typeof backendUrl === 'string') {
+    return backendUrl;
+  }
+  return invoke('Layout.getBackendUrl');
 };
 
 const state$3 = {
@@ -2171,6 +2167,259 @@ const getOidcUserName = async (backendUrl, accessToken, fetchFn = fetch) => {
   return typeof displayName === 'string' ? displayName : '';
 };
 
+const instanceOfAny = (object, constructors) => constructors.some(c => object instanceof c);
+let idbProxyableTypes;
+let cursorAdvanceMethods;
+// This is a function to prevent it throwing up in node environments.
+function getIdbProxyableTypes() {
+  return idbProxyableTypes || (idbProxyableTypes = [IDBIndex, IDBObjectStore, IDBCursor, IDBDatabase, IDBTransaction]);
+}
+// This is a function to prevent it throwing up in node environments.
+function getCursorAdvanceMethods() {
+  return cursorAdvanceMethods || (cursorAdvanceMethods = ['advance', 'continue', 'continuePrimaryKey'].map(method => IDBCursor.prototype[method]));
+}
+const transactionDoneMap = new WeakMap();
+const transformCache = new WeakMap();
+const reverseTransformCache = new WeakMap();
+function promisifyRequest(request) {
+  const promise = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      request.removeEventListener('success', success);
+      request.removeEventListener('error', error);
+    };
+    const success = () => {
+      resolve(wrap(request.result));
+      unlisten();
+    };
+    const error = () => {
+      reject(request.error);
+      unlisten();
+    };
+    request.addEventListener('success', success);
+    request.addEventListener('error', error);
+  });
+  // This mapping exists in reverseTransformCache but doesn't exist in transformCache. This
+  // is because we create many promises from a single IDBRequest.
+  reverseTransformCache.set(promise, request);
+  return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+  // Early bail if we've already created a done promise for this transaction.
+  if (transactionDoneMap.has(tx)) return;
+  const done = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      tx.removeEventListener('complete', complete);
+      tx.removeEventListener('error', error);
+      tx.removeEventListener('abort', error);
+    };
+    const complete = () => {
+      resolve();
+      unlisten();
+    };
+    const error = () => {
+      reject(tx.error || new DOMException('AbortError', 'AbortError'));
+      unlisten();
+    };
+    tx.addEventListener('complete', complete);
+    tx.addEventListener('error', error);
+    tx.addEventListener('abort', error);
+  });
+  // Cache it for later retrieval.
+  transactionDoneMap.set(tx, done);
+}
+let idbProxyTraps = {
+  get(target, prop, receiver) {
+    if (target instanceof IDBTransaction) {
+      // Special handling for transaction.done.
+      if (prop === 'done') return transactionDoneMap.get(target);
+      // Make tx.store return the only store in the transaction, or undefined if there are many.
+      if (prop === 'store') {
+        return receiver.objectStoreNames[1] ? undefined : receiver.objectStore(receiver.objectStoreNames[0]);
+      }
+    }
+    // Else transform whatever we get back.
+    return wrap(target[prop]);
+  },
+  set(target, prop, value) {
+    target[prop] = value;
+    return true;
+  },
+  has(target, prop) {
+    if (target instanceof IDBTransaction && (prop === 'done' || prop === 'store')) {
+      return true;
+    }
+    return prop in target;
+  }
+};
+function replaceTraps(callback) {
+  idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+  // Due to expected object equality (which is enforced by the caching in `wrap`), we
+  // only create one new func per func.
+  // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
+  // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the
+  // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense
+  // with real promises, so each advance methods returns a new promise for the cursor object, or
+  // undefined if the end of the cursor has been reached.
+  if (getCursorAdvanceMethods().includes(func)) {
+    return function (...args) {
+      // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+      // the original object.
+      func.apply(unwrap(this), args);
+      return wrap(this.request);
+    };
+  }
+  return function (...args) {
+    // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+    // the original object.
+    return wrap(func.apply(unwrap(this), args));
+  };
+}
+function transformCachableValue(value) {
+  if (typeof value === 'function') return wrapFunction(value);
+  // This doesn't return, it just creates a 'done' promise for the transaction,
+  // which is later returned for transaction.done (see idbObjectHandler).
+  if (value instanceof IDBTransaction) cacheDonePromiseForTransaction(value);
+  if (instanceOfAny(value, getIdbProxyableTypes())) return new Proxy(value, idbProxyTraps);
+  // Return the same value back if we're not going to transform it.
+  return value;
+}
+function wrap(value) {
+  // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
+  // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
+  if (value instanceof IDBRequest) return promisifyRequest(value);
+  // If we've already transformed this value before, reuse the transformed value.
+  // This is faster, but it also provides object equality.
+  if (transformCache.has(value)) return transformCache.get(value);
+  const newValue = transformCachableValue(value);
+  // Not all types are transformed.
+  // These may be primitive types, so they can't be WeakMap keys.
+  if (!Object.is(newValue, value)) {
+    transformCache.set(value, newValue);
+    reverseTransformCache.set(newValue, value);
+  }
+  return newValue;
+}
+const unwrap = value => reverseTransformCache.get(value);
+
+/**
+ * Open a database.
+ *
+ * @param name Name of the database.
+ * @param version Schema version.
+ * @param callbacks Additional callbacks.
+ */
+function openDB(name, version, {
+  blocked,
+  upgrade,
+  blocking,
+  terminated
+} = {}) {
+  const request = indexedDB.open(name, version);
+  const openPromise = wrap(request);
+  if (upgrade) {
+    request.addEventListener('upgradeneeded', event => {
+      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
+    });
+  }
+  if (blocked) {
+    request.addEventListener('blocked', event => blocked(
+    // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+    event.oldVersion, event.newVersion, event));
+  }
+  openPromise.then(db => {
+    if (terminated) db.addEventListener('close', () => terminated());
+    if (blocking) {
+      db.addEventListener('versionchange', event => blocking(event.oldVersion, event.newVersion, event));
+    }
+  }).catch(() => {});
+  return openPromise;
+}
+const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
+const writeMethods = ['put', 'add', 'delete', 'clear'];
+const cachedMethods = {};
+function getMethod(target, prop) {
+  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === 'string')) {
+    return;
+  }
+  if (cachedMethods[prop]) return cachedMethods[prop];
+  const targetFuncName = prop.replace(/FromIndex$/, '');
+  const useIndex = prop !== targetFuncName;
+  const isWrite = writeMethods.includes(targetFuncName);
+  if (
+  // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+  !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) {
+    return;
+  }
+  const method = async function (storeName, ...args) {
+    // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(
+    const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
+    let target = tx.store;
+    if (useIndex) target = target.index(args.shift());
+    // Must reject if op rejects.
+    // If it's a write operation, must reject if tx.done rejects.
+    // Must reject with op rejection first.
+    // Must resolve with op value.
+    // Must handle both promises (no unhandled rejections)
+    return (await Promise.all([target[targetFuncName](...args), isWrite && tx.done]))[0];
+  };
+  return cachedMethods[prop] = method;
+}
+replaceTraps(oldTraps => ({
+  ...oldTraps,
+  get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+  has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
+}));
+const advanceMethodProps = ['advance', 'continue', 'continuePrimaryKey'];
+const methodMap = {};
+const advanceResults = new WeakMap();
+const ittrProxiedCursorToOriginalProxy = new WeakMap();
+const cursorIteratorTraps = {
+  get(target, prop) {
+    if (!advanceMethodProps.includes(prop)) return target[prop];
+    let cachedFunc = methodMap[prop];
+    if (!cachedFunc) {
+      cachedFunc = methodMap[prop] = function (...args) {
+        advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
+      };
+    }
+    return cachedFunc;
+  }
+};
+async function* iterate(...args) {
+  // tslint:disable-next-line:no-this-assignment
+  let cursor = this;
+  if (!(cursor instanceof IDBCursor)) {
+    cursor = await cursor.openCursor(...args);
+  }
+  if (!cursor) return;
+  cursor = cursor;
+  const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
+  ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
+  // Map this double-proxy back to the original, so other cursor methods work.
+  reverseTransformCache.set(proxiedCursor, unwrap(cursor));
+  while (cursor) {
+    yield proxiedCursor;
+    // If one of the advancing methods was not called, call continue().
+    cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
+    advanceResults.delete(proxiedCursor);
+  }
+}
+function isIteratorProp(target, prop) {
+  return prop === Symbol.asyncIterator && instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor]) || prop === 'iterate' && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
+}
+replaceTraps(oldTraps => ({
+  ...oldTraps,
+  get(target, prop, receiver) {
+    if (isIteratorProp(target, prop)) return iterate;
+    return oldTraps.get(target, prop, receiver);
+  },
+  has(target, prop) {
+    return isIteratorProp(target, prop) || oldTraps.has(target, prop);
+  }
+}));
+
 const authStorageId = 'lvce-editor.auth';
 const deleteSecret = async key => {
   await deleteSecret$1(authStorageId, key);
@@ -2189,53 +2438,18 @@ const secretKeys = new Set(['accessToken', 'refreshToken', 'accountSessions']);
 const state$2 = {
   databasePromise: undefined
 };
-
-// IndexedDB request objects are mutable browser primitives and cannot satisfy the readonly rule structurally.
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-const requestToPromise = request => {
-  return new Promise((resolve, reject) => {
-    request.addEventListener('success', () => {
-      resolve(request.result);
-    });
-    request.addEventListener('error', () => {
-      reject(request.error ?? new Error('Persistent storage request failed.'));
-    });
-  });
-};
-
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-const transactionToPromise = transaction => {
-  return new Promise((resolve, reject) => {
-    transaction.addEventListener('complete', () => {
-      resolve();
-    });
-    transaction.addEventListener('abort', () => {
-      reject(transaction.error ?? new Error('Persistent storage transaction failed.'));
-    });
-    transaction.addEventListener('error', () => {
-      reject(transaction.error ?? new Error('Persistent storage transaction failed.'));
-    });
-  });
-};
 const getDatabase = async () => {
   if (typeof indexedDB === 'undefined') {
     return undefined;
   }
   if (!state$2.databasePromise) {
-    state$2.databasePromise = new Promise((resolve, reject) => {
-      const request = indexedDB.open(databaseName, 1);
-      request.addEventListener('upgradeneeded', () => {
-        const database = request.result;
+    state$2.databasePromise = openDB(databaseName, 1, {
+      // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+      upgrade(database) {
         if (!database.objectStoreNames.contains(objectStoreName)) {
           database.createObjectStore(objectStoreName);
         }
-      });
-      request.addEventListener('success', () => {
-        resolve(request.result);
-      });
-      request.addEventListener('error', () => {
-        reject(request.error ?? new Error('Failed to open persistent auth storage.'));
-      });
+      }
     });
   }
   return state$2.databasePromise;
@@ -2245,9 +2459,7 @@ const getIndexedDbValue = async key => {
   if (!database) {
     return memoryStorage.get(key) ?? '';
   }
-  const transaction = database.transaction(objectStoreName, 'readonly');
-  const objectStore = transaction.objectStore(objectStoreName);
-  const value = await requestToPromise(objectStore.get(key));
+  const value = await database.get(objectStoreName, key);
   return typeof value === 'string' ? value : '';
 };
 const setIndexedDbValue = async (key, value) => {
@@ -2256,10 +2468,7 @@ const setIndexedDbValue = async (key, value) => {
   if (!database) {
     return;
   }
-  const transaction = database.transaction(objectStoreName, 'readwrite');
-  const objectStore = transaction.objectStore(objectStoreName);
-  objectStore.put(value, key);
-  await transactionToPromise(transaction);
+  await database.put(objectStoreName, value, key);
 };
 const clearIndexedDbValue = async key => {
   memoryStorage.delete(key);
@@ -2267,10 +2476,7 @@ const clearIndexedDbValue = async key => {
   if (!database) {
     return;
   }
-  const transaction = database.transaction(objectStoreName, 'readwrite');
-  const objectStore = transaction.objectStore(objectStoreName);
-  objectStore.delete(key);
-  await transactionToPromise(transaction);
+  await database.delete(objectStoreName, key);
 };
 const shouldUseSecretStorage = key => {
   return getAuthPlatform() === Electron && secretKeys.has(key);
@@ -2279,17 +2485,7 @@ const getPersistentAuthValue = async key => {
   if (!shouldUseSecretStorage(key)) {
     return getIndexedDbValue(key);
   }
-  const secret = await getSecret(key);
-  if (secret) {
-    return secret;
-  }
-  const legacyValue = await getIndexedDbValue(key);
-  if (!legacyValue) {
-    return '';
-  }
-  await storeSecret(key, legacyValue);
-  await clearIndexedDbValue(key);
-  return legacyValue;
+  return (await getSecret(key)) || '';
 };
 const setPersistentAuthValue = async (key, value) => {
   if (!shouldUseSecretStorage(key)) {
@@ -2550,58 +2746,9 @@ const userNameKey = 'userName';
 const userSubscriptionPlanKey = 'userSubscriptionPlan';
 const userSubscriptionStatusKey = 'userSubscriptionStatus';
 const userUsedTokensKey = 'userUsedTokens';
-const toOptionalString = value => {
-  return value || undefined;
-};
-const toOptionalNumber = value => {
-  if (!value) {
-    return undefined;
-  }
-  const numberValue = Number(value);
-  return Number.isFinite(numberValue) ? numberValue : undefined;
-};
 const clearPersistedAuthSession = async () => {
   await Promise.all([clearPersistentAuthValue(accessTokenKey), clearPersistentAuthValue(accessTokenExpiresAtKey), clearPersistentAuthValue(refreshTokenKey), clearStoredOidcClientId(), clearPersistentAuthValue(userNameKey), clearPersistentAuthValue(userSubscriptionPlanKey), clearPersistentAuthValue(userSubscriptionStatusKey), clearPersistentAuthValue(userUsedTokensKey)]);
 };
-const getPersistedAuthSession = async () => {
-  const [accessToken, accessTokenExpiresAt, refreshToken, authClientId, userName, userSubscriptionPlan, userSubscriptionStatus, userUsedTokens] = await Promise.all([getPersistentAuthValue(accessTokenKey), getPersistentAuthValue(accessTokenExpiresAtKey), getPersistentAuthValue(refreshTokenKey), getStoredOidcClientId(), getPersistentAuthValue(userNameKey), getPersistentAuthValue(userSubscriptionPlanKey), getPersistentAuthValue(userSubscriptionStatusKey), getPersistentAuthValue(userUsedTokensKey)]);
-  if (!accessToken && !refreshToken) {
-    return undefined;
-  }
-  const optionalAuthClientId = toOptionalString(authClientId);
-  const optionalAccessTokenExpiresAt = toOptionalNumber(accessTokenExpiresAt);
-  const optionalRefreshToken = toOptionalString(refreshToken);
-  const optionalUserName = toOptionalString(userName);
-  const optionalSubscriptionPlan = toOptionalString(userSubscriptionPlan);
-  const optionalSubscriptionStatus = toOptionalString(userSubscriptionStatus);
-  const optionalUsedTokens = toOptionalNumber(userUsedTokens);
-  return {
-    authAccessToken: accessToken,
-    ...(typeof optionalAccessTokenExpiresAt === 'number' && {
-      authAccessTokenExpiresAt: optionalAccessTokenExpiresAt
-    }),
-    authErrorMessage: '',
-    userState: 'loggedIn',
-    ...(optionalAuthClientId && {
-      authClientId
-    }),
-    ...(optionalRefreshToken && {
-      authRefreshToken: refreshToken
-    }),
-    ...(optionalUserName && {
-      userName
-    }),
-    ...(optionalSubscriptionPlan && {
-      userSubscriptionPlan
-    }),
-    ...(optionalSubscriptionStatus && {
-      userSubscriptionStatus
-    }),
-    ...(typeof optionalUsedTokens === 'number' && {
-      userUsedTokens: optionalUsedTokens
-    })
-  };
-};
 const persistAuthSession = async loginResult => {
   await Promise.all([setPersistentAuthValue(accessTokenKey, loginResult.authAccessToken ?? ''), setPersistentAuthValue(accessTokenExpiresAtKey, typeof loginResult.authAccessTokenExpiresAt === 'number' ? String(loginResult.authAccessTokenExpiresAt) : ''), setPersistentAuthValue(refreshTokenKey, loginResult.authRefreshToken ?? ''), loginResult.authClientId ? saveOidcClientId(loginResult.authClientId) : clearStoredOidcClientId(), setPersistentAuthValue(userNameKey, loginResult.userName ?? ''), setPersistentAuthValue(userSubscriptionPlanKey, loginResult.userSubscriptionPlan ?? ''), setPersistentAuthValue(userSubscriptionStatusKey, loginResult.userSubscriptionStatus ?? ''), setPersistentAuthValue(userUsedTokensKey, typeof loginResult.userUsedTokens === 'number' ? String(loginResult.userUsedTokens) : '')]);
 };
@@ -3254,10 +3401,13 @@ const accounts = createAccountSessions({
 });
 const refreshes = new Map();
 const state = {
-  login: undefined,
-  migration: undefined
+  login: undefined
 };
 const normalizeBackendUrl = backendUrl => new URL(backendUrl).origin;
+const getNormalizedBackendUrl = async backendUrl => {
+  const url = await getAuthBackendUrl(backendUrl);
+  return url ? normalizeBackendUrl(url) : '';
+};
 const addSession = async (backendUrl, session, revision) => {
   if (session.userState !== 'loggedIn' || !session.authAccessToken) {
     return;
@@ -3273,55 +3423,6 @@ const addSession = async (backendUrl, session, revision) => {
     }
   }, revision);
 };
-const migrate = async backendUrl => {
-  if (await getPersistentAuthValue(storageKey)) {
-    return;
-  }
-  const legacy = await getPersistedAuthSession();
-  if (legacy) {
-    if (legacy.authClientId && legacy.authRefreshToken) {
-      const tokens = await refreshOidcTokens(backendUrl, legacy.authClientId, legacy.authRefreshToken);
-      const authAccessTokenExpiresAt = getAccessTokenExpiresAt(tokens.expiresIn);
-      const {
-        authAccessTokenExpiresAt: _legacyExpiry,
-        ...legacySession
-      } = legacy;
-      await addSession(backendUrl, {
-        ...legacySession,
-        authAccessToken: tokens.accessToken,
-        ...(authAccessTokenExpiresAt && {
-          authAccessTokenExpiresAt
-        }),
-        authRefreshToken: tokens.refreshToken
-      }, 0);
-    } else {
-      await addSession(backendUrl, legacy, 0);
-    }
-  } else {
-    await setPersistentAuthValue(storageKey, JSON.stringify({
-      accounts: [],
-      activeId: '',
-      revision: 0
-    }));
-  }
-  // Clear legacy credentials only after the registry is durably committed.
-  await clearPersistedAuthSession();
-};
-const ensureMigrated = async (backendUrl = getAuthBackendUrl()) => {
-  const url = normalizeBackendUrl(backendUrl);
-  if (!state.migration) {
-    state.migration = (async () => {
-      try {
-        await migrate(url);
-      } catch (error) {
-        state.migration = undefined;
-        throw error;
-      }
-    })();
-  }
-  await state.migration;
-  return url;
-};
 const getActive = async backendUrl => {
   const registry = await accounts.read();
   return registry.accounts.find(account => account.id === registry.activeId && account.backendUrl === backendUrl);
@@ -3387,13 +3488,17 @@ const getConnectionRequestHeaders = accessToken => {
   };
 };
 const getConnectedAccounts = async () => {
-  const backendUrl = await ensureMigrated();
+  const backendUrl = await getNormalizedBackendUrl();
   const accessToken = await getAccessToken({
+    backendUrl,
     refresh: 'if-needed'
   });
   if (!accessToken) {
     return [];
   }
+  if (backendUrl !== (await getNormalizedBackendUrl())) {
+    throw new Error('Account backend changed. Retry connected accounts.');
+  }
   const response = await fetch(getConnectedAccountsUrl(backendUrl), {
     headers: getConnectionRequestHeaders(accessToken)
   });
@@ -3407,13 +3512,17 @@ const getConnectedAccounts = async () => {
   return payload.connections;
 };
 const disconnectConnectedAccount = async provider => {
-  const backendUrl = await ensureMigrated();
+  const backendUrl = await getNormalizedBackendUrl();
   const accessToken = await getAccessToken({
+    backendUrl,
     refresh: 'if-needed'
   });
   if (!accessToken) {
     throw new Error('Sign in to disconnect connected accounts.');
   }
+  if (backendUrl !== (await getNormalizedBackendUrl())) {
+    throw new Error('Account backend changed. Retry connected accounts.');
+  }
   const response = await fetch(getConnectedAccountDisconnectUrl(backendUrl, provider), {
     headers: getConnectionRequestHeaders(accessToken),
     method: 'POST'
@@ -3423,7 +3532,7 @@ const disconnectConnectedAccount = async provider => {
   }
 };
 const getAccounts = async () => {
-  const backendUrl = await ensureMigrated();
+  const backendUrl = await getNormalizedBackendUrl();
   const registry = await accounts.read();
   return registry.accounts.filter(account => account.backendUrl === backendUrl).map(account => ({
     ...account.profile,
@@ -3434,7 +3543,10 @@ const getAccounts = async () => {
   }));
 };
 const getAccessToken = async (options = {}) => {
-  const backendUrl = await ensureMigrated();
+  const backendUrl = await getNormalizedBackendUrl(options.backendUrl);
+  if (!backendUrl) {
+    return '';
+  }
   const account = await getActive(backendUrl);
   if (!account) {
     return '';
@@ -3460,7 +3572,7 @@ const initialize = async (options = {}) => {
   if (typeof options.platform === 'number') {
     setAuthPlatform(options.platform);
   }
-  const backendUrl = await ensureMigrated(options.backendUrl);
+  const backendUrl = await getNormalizedBackendUrl(options.backendUrl);
   const registry = await accounts.read();
   const completed = await completeBrowserOidcLogin(backendUrl);
   if (completed) {
@@ -3469,6 +3581,7 @@ const initialize = async (options = {}) => {
   }
   try {
     await getAccessToken({
+      backendUrl,
       refresh: 'if-needed'
     });
     return getCurrentState(backendUrl);
@@ -3481,7 +3594,7 @@ const login = async options => {
     return state.login;
   }
   const operation = (async () => {
-    const backendUrl = await ensureMigrated(options.backendUrl);
+    const backendUrl = await getNormalizedBackendUrl(options.backendUrl);
     const registry = await accounts.read();
     const result = await handleClickLogin({
       ...options,
@@ -3498,7 +3611,7 @@ const login = async options => {
   }
 };
 const useAccount = async id => {
-  const backendUrl = await ensureMigrated();
+  const backendUrl = await getNormalizedBackendUrl();
   const registry = await accounts.read();
   if (registry.accounts.every(account => !(account.id === id && account.backendUrl === backendUrl))) {
     throw new Error('Account is no longer available.');
@@ -3507,7 +3620,7 @@ const useAccount = async id => {
   return getCurrentState(backendUrl);
 };
 const removeAccount = async id => {
-  const backendUrl = await ensureMigrated();
+  const backendUrl = await getNormalizedBackendUrl();
   const registry = await accounts.read();
   if (registry.accounts.some(account => account.id === id && account.backendUrl === backendUrl)) {
     await accounts.remove(id);
@@ -3515,7 +3628,7 @@ const removeAccount = async id => {
   return getCurrentState(backendUrl);
 };
 const logout = async () => {
-  const backendUrl = await ensureMigrated();
+  const backendUrl = await getNormalizedBackendUrl();
   const account = await getActive(backendUrl);
   return account ? removeAccount(account.id) : getLoggedOutBackendAuthState();
 };
@@ -3525,13 +3638,18 @@ const syncBackendAuth = async backendUrl => initialize({
 
 const identifier = /^[a-f0-9]{32}$/;
 const confirmationCode = /^[A-F0-9]{8}$/;
-const getCloudflareConnectionsUrl = () => new URL('/cloudflare', getAuthBackendUrl()).href;
+const getCloudflareConnectionsUrl = async () => {
+  const backendUrl = await getAuthBackendUrl();
+  return backendUrl ? new URL('/cloudflare', backendUrl).href : '';
+};
 const request = async (pathname, method = 'GET', body) => {
-  const backendUrl = getAuthBackendUrl();
+  const backendUrl = await getAuthBackendUrl();
+  if (!backendUrl) throw new Error('Sign in to LVCE to manage Cloudflare connections.');
   const accessToken = await getAccessToken({
+    backendUrl,
     refresh: 'if-needed'
   });
-  if (backendUrl !== getAuthBackendUrl()) throw new Error('Account backend changed. Retry Cloudflare setup.');
+  if (backendUrl !== (await getAuthBackendUrl())) throw new Error('Account backend changed. Retry Cloudflare setup.');
   if (!accessToken) throw new Error('Sign in to LVCE to manage Cloudflare connections.');
   const response = await fetch(new URL(pathname, backendUrl), {
     headers: {
@@ -3582,7 +3700,6 @@ const initializeMainProcess = async () => {
 };
 
 const configure = async options => {
-  setAuthBackendUrl(options.backendUrl);
   setAuthPlatform(options.platform);
   setUseNativeAuth(options.useNativeAuth === true);
   if (options.platform === Electron) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/auth-worker",
-  "version": "3.22.0",
+  "version": "3.22.2",
   "description": "Auth Worker",
   "repository": {
     "type": "git",