@lvce-editor/auth-worker 3.22.1 → 3.22.3

package/dist/authWorkerMain.js

@@ -1102,6 +1102,7 @@ const create = rpcId => {
 };
 
 const {
+  dispose,
   invoke: invoke$3,
   set: set$2
 } = create(6040);
@@ -1241,32 +1242,29 @@ 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 = {
+const state$4 = {
   platform: Web,
   useNativeAuth: false
 };
 const getAuthPlatform = () => {
-  return state$3.platform;
+  return state$4.platform;
 };
 const setAuthPlatform = value => {
-  state$3.platform = value;
+  state$4.platform = value;
 };
 
 // Native shells can use loopback OAuth without Electron's process or secret storage.
 const setUseNativeAuth = value => {
-  state$3.useNativeAuth = value;
+  state$4.useNativeAuth = value;
 };
-const getUseNativeAuth = () => state$3.useNativeAuth;
+const getUseNativeAuth = () => state$4.useNativeAuth;
 
 let USER_AGENT;
 if (typeof navigator === 'undefined' || !navigator.userAgent?.startsWith?.('Mozilla/5.0 ')) {
@@ -2438,15 +2436,15 @@ const databaseName = 'auth-worker';
 const objectStoreName = 'auth';
 const memoryStorage = new Map();
 const secretKeys = new Set(['accessToken', 'refreshToken', 'accountSessions']);
-const state$2 = {
+const state$3 = {
   databasePromise: undefined
 };
 const getDatabase = async () => {
   if (typeof indexedDB === 'undefined') {
     return undefined;
   }
-  if (!state$2.databasePromise) {
-    state$2.databasePromise = openDB(databaseName, 1, {
+  if (!state$3.databasePromise) {
+    state$3.databasePromise = openDB(databaseName, 1, {
       // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
       upgrade(database) {
         if (!database.objectStoreNames.contains(objectStoreName)) {
@@ -2455,7 +2453,7 @@ const getDatabase = async () => {
       }
     });
   }
-  return state$2.databasePromise;
+  return state$3.databasePromise;
 };
 const getIndexedDbValue = async key => {
   const database = await getDatabase();
@@ -2651,32 +2649,32 @@ const delay = async ms => {
   await new Promise(resolve => setTimeout(resolve, ms));
 };
 
-const state$1 = {
+const state$2 = {
   nextLoginResponse: undefined,
   nextRefreshResponse: undefined
 };
 const setNextLoginResponse = response => {
-  state$1.nextLoginResponse = response;
+  state$2.nextLoginResponse = response;
 };
 const setNextRefreshResponse = response => {
-  state$1.nextRefreshResponse = response;
+  state$2.nextRefreshResponse = response;
 };
 const clear = () => {
-  state$1.nextLoginResponse = undefined;
-  state$1.nextRefreshResponse = undefined;
+  state$2.nextLoginResponse = undefined;
+  state$2.nextRefreshResponse = undefined;
 };
 const hasPendingMockLoginResponse = () => {
-  return !!state$1.nextLoginResponse;
+  return !!state$2.nextLoginResponse;
 };
 const hasPendingMockRefreshResponse = () => {
-  return !!state$1.nextRefreshResponse;
+  return !!state$2.nextRefreshResponse;
 };
 const consumeNextLoginResponse = async () => {
-  if (!state$1.nextLoginResponse) {
+  if (!state$2.nextLoginResponse) {
     return undefined;
   }
-  const response = state$1.nextLoginResponse;
-  state$1.nextLoginResponse = undefined;
+  const response = state$2.nextLoginResponse;
+  state$2.nextLoginResponse = undefined;
   if (response.delay > 0) {
     await delay(response.delay);
   }
@@ -2686,11 +2684,11 @@ const consumeNextLoginResponse = async () => {
   return response.response;
 };
 const consumeNextRefreshResponse = async () => {
-  if (!state$1.nextRefreshResponse) {
+  if (!state$2.nextRefreshResponse) {
     return undefined;
   }
-  const response = state$1.nextRefreshResponse;
-  state$1.nextRefreshResponse = undefined;
+  const response = state$2.nextRefreshResponse;
+  state$2.nextRefreshResponse = undefined;
   if (response.delay > 0) {
     await new Promise(resolve => setTimeout(resolve, response.delay));
   }
@@ -3305,6 +3303,9 @@ const waitForElectronBackendLogin = async (backendUrl, uid, redirectUri, codeVer
   return getLoggedOutBackendAuthState('Timed out waiting for backend login.');
 };
 
+const state$1 = {
+  nativeLoginCount: 0
+};
 const getMockLoginResult = async (signingInState, persistResult) => {
   if (!hasPendingMockLoginResponse()) {
     return undefined;
@@ -3325,10 +3326,13 @@ const getMockLoginResult = async (signingInState, persistResult) => {
   return persistResult(getLoggedInState(signingInState, response));
 };
 const getInteractiveLoginResult = async (backendUrl, platform, signingInState, persistResult, selectAccount) => {
-  const nativeAuth = getUseNativeAuth();
+  const nativeAuth = getUseNativeAuth() || platform === Electron;
   const transportPlatform = nativeAuth ? Electron : platform;
   const authUseRedirect = getAuthUseRedirect(transportPlatform);
   const uid = nativeAuth ? globalThis.crypto.randomUUID() : 0;
+  if (nativeAuth) {
+    state$1.nativeLoginCount++;
+  }
   try {
     const {
       clientId,
@@ -3361,7 +3365,14 @@ const getInteractiveLoginResult = async (backendUrl, platform, signingInState, p
     });
   } finally {
     if (nativeAuth) {
-      await invoke$3('OAuthServer.dispose', String(uid));
+      try {
+        await invoke$3('OAuthServer.dispose', String(uid));
+      } finally {
+        state$1.nativeLoginCount--;
+        if (state$1.nativeLoginCount === 0) {
+          await dispose();
+        }
+      }
     }
   }
 };
@@ -3407,7 +3418,10 @@ const state = {
   login: undefined
 };
 const normalizeBackendUrl = backendUrl => new URL(backendUrl).origin;
-const getNormalizedBackendUrl = (backendUrl = getAuthBackendUrl()) => normalizeBackendUrl(backendUrl);
+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;
@@ -3488,13 +3502,17 @@ const getConnectionRequestHeaders = accessToken => {
   };
 };
 const getConnectedAccounts = async () => {
-  const backendUrl = getNormalizedBackendUrl();
+  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)
   });
@@ -3508,13 +3526,17 @@ const getConnectedAccounts = async () => {
   return payload.connections;
 };
 const disconnectConnectedAccount = async provider => {
-  const backendUrl = getNormalizedBackendUrl();
+  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'
@@ -3524,7 +3546,7 @@ const disconnectConnectedAccount = async provider => {
   }
 };
 const getAccounts = async () => {
-  const backendUrl = getNormalizedBackendUrl();
+  const backendUrl = await getNormalizedBackendUrl();
   const registry = await accounts.read();
   return registry.accounts.filter(account => account.backendUrl === backendUrl).map(account => ({
     ...account.profile,
@@ -3535,7 +3557,10 @@ const getAccounts = async () => {
   }));
 };
 const getAccessToken = async (options = {}) => {
-  const backendUrl = getNormalizedBackendUrl();
+  const backendUrl = await getNormalizedBackendUrl(options.backendUrl);
+  if (!backendUrl) {
+    return '';
+  }
   const account = await getActive(backendUrl);
   if (!account) {
     return '';
@@ -3561,7 +3586,7 @@ const initialize = async (options = {}) => {
   if (typeof options.platform === 'number') {
     setAuthPlatform(options.platform);
   }
-  const backendUrl = getNormalizedBackendUrl(options.backendUrl ?? getAuthBackendUrl());
+  const backendUrl = await getNormalizedBackendUrl(options.backendUrl);
   const registry = await accounts.read();
   const completed = await completeBrowserOidcLogin(backendUrl);
   if (completed) {
@@ -3570,6 +3595,7 @@ const initialize = async (options = {}) => {
   }
   try {
     await getAccessToken({
+      backendUrl,
       refresh: 'if-needed'
     });
     return getCurrentState(backendUrl);
@@ -3582,7 +3608,7 @@ const login = async options => {
     return state.login;
   }
   const operation = (async () => {
-    const backendUrl = getNormalizedBackendUrl(options.backendUrl ?? getAuthBackendUrl());
+    const backendUrl = await getNormalizedBackendUrl(options.backendUrl);
     const registry = await accounts.read();
     const result = await handleClickLogin({
       ...options,
@@ -3599,7 +3625,7 @@ const login = async options => {
   }
 };
 const useAccount = async id => {
-  const backendUrl = getNormalizedBackendUrl();
+  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.');
@@ -3608,7 +3634,7 @@ const useAccount = async id => {
   return getCurrentState(backendUrl);
 };
 const removeAccount = async id => {
-  const backendUrl = getNormalizedBackendUrl();
+  const backendUrl = await getNormalizedBackendUrl();
   const registry = await accounts.read();
   if (registry.accounts.some(account => account.id === id && account.backendUrl === backendUrl)) {
     await accounts.remove(id);
@@ -3616,7 +3642,7 @@ const removeAccount = async id => {
   return getCurrentState(backendUrl);
 };
 const logout = async () => {
-  const backendUrl = getNormalizedBackendUrl();
+  const backendUrl = await getNormalizedBackendUrl();
   const account = await getActive(backendUrl);
   return account ? removeAccount(account.id) : getLoggedOutBackendAuthState();
 };
@@ -3626,13 +3652,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: {
@@ -3660,15 +3691,76 @@ const approveCloudflareMachine = (id, code, zoneId) => {
   });
 };
 
-const sendMessagePortToAuthProcess = async port => {
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, 'HandleMessagePortForAuthProcess.handleMessagePortForAuthProcess');
+const connect = async () => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  const closed = Promise.withResolvers();
+  const handleClose = () => closed.resolve(new Error('Auth process connection closed'));
+  port2.addEventListener('close', handleClose, {
+    once: true
+  });
+  const failOnClose = async () => {
+    throw await closed.promise;
+  };
+  const raceClose = promise => Promise.race([promise, failOnClose()]);
+  try {
+    await raceClose(invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port1, 'HandleMessagePortForAuthProcess.handleMessagePortForAuthProcess'));
+    const rpc = await create$4({
+      commandMap: {},
+      messagePort: port2
+    });
+    return {
+      async dispose() {
+        handleClose();
+        port2.removeEventListener('close', handleClose);
+        await rpc.dispose();
+      },
+      invoke: (method, ...params) => raceClose(rpc.invoke(method, ...params)),
+      invokeAndTransfer: (method, ...params) => raceClose(rpc.invokeAndTransfer(method, ...params)),
+      send: rpc.send
+    };
+  } catch (error) {
+    port2.removeEventListener('close', handleClose);
+    port1.close();
+    port2.close();
+    throw error;
+  }
+};
+const createAuthProcessRpc = (create = connect) => {
+  let pending;
+  const get = () => {
+    if (!pending) {
+      pending = create();
+    }
+    return pending;
+  };
+  return {
+    async dispose() {
+      const previous = pending;
+      // Detach before awaiting: a new login may connect while the old port closes.
+      pending = undefined;
+      if (previous) {
+        const rpc = await previous;
+        await rpc.dispose();
+      }
+    },
+    async invoke(method, ...params) {
+      const rpc = await get();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await get();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    send(method, ...params) {
+      void get().then(rpc => rpc.send(method, ...params));
+    }
+  };
 };
 const initializeAuthProcess = async () => {
-  const rpc = await create$2({
-    commandMap: {},
-    send: sendMessagePortToAuthProcess
-  });
-  set$2(rpc);
+  set$2(createAuthProcessRpc());
 };
 
 const sendMessagePortToMainProcess = async port => {
@@ -3683,7 +3775,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.1",
+  "version": "3.22.3",
   "description": "Auth Worker",
   "repository": {
     "type": "git",