@lvce-editor/auth-worker 3.6.0 → 3.7.0

package/dist/authWorkerMain.js

@@ -1009,7 +1009,7 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$2 = (id, rpc) => {
+const set$3 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
@@ -1042,7 +1042,7 @@ const create = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$2(rpcId, mockRpc);
+      set$3(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -1051,33 +1051,44 @@ const create = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$2(rpcId, rpc);
+      set$3(rpcId, rpc);
     }
   };
 };
 
 const {
-  invoke: invoke$2,
-  set: set$1
+  invoke: invoke$3,
+  set: set$2
 } = create(6040);
 
+const Web = 1;
 const Electron = 2;
 
 const OpenerWorker = 4561;
 const RendererWorker = 1;
+const SharedProcess = 1492;
 
 const {
-  invoke: invoke$1,
-  set
+  invoke: invoke$2,
+  set: set$1
 } = create(OpenerWorker);
 
 const {
-  invoke,
+  invoke: invoke$1,
   invokeAndTransfer} = create(RendererWorker);
 const sendMessagePortToOpenerWorker$1 = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToOpenerWorker', port, command, rpcId);
 };
+const sendMessagePortToSharedProcess$1 = async port => {
+  const command = 'HandleElectronMessagePort.handleElectronMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, 0);
+};
+
+const {
+  invoke,
+  set
+} = create(SharedProcess);
 
 const sendMessagePortToAuthProcess = async port => {
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, 'HandleMessagePortForAuthProcess.handleMessagePortForAuthProcess');
@@ -1087,7 +1098,7 @@ const initializeAuthProcess = async () => {
     commandMap: {},
     send: sendMessagePortToAuthProcess
   });
-  set$1(rpc);
+  set$2(rpc);
 };
 
 const sendMessagePortToOpenerWorker = async port => {
@@ -1098,7 +1109,7 @@ const initializeOpenerWorker = async () => {
     commandMap: {},
     send: sendMessagePortToOpenerWorker
   });
-  set(rpc);
+  set$1(rpc);
 };
 
 const millisecondsPerSecond = 1000;
@@ -1116,19 +1127,42 @@ const isAccessTokenValid = (accessToken, expiresAt, now = Date.now()) => {
   return Number.isFinite(expiresAtNumber) && expiresAtNumber > now;
 };
 
-const state$2 = {
+const state$3 = {
   backendUrl: ''
 };
 const getAuthBackendUrl = () => {
-  return state$2.backendUrl;
+  return state$3.backendUrl;
 };
 const setAuthBackendUrl = backendUrl => {
-  state$2.backendUrl = backendUrl;
+  state$3.backendUrl = backendUrl;
+};
+
+const state$2 = {
+  platform: Web
+};
+const getAuthPlatform = () => {
+  return state$2.platform;
+};
+const setAuthPlatform = value => {
+  state$2.platform = value;
+};
+
+const authStorageId = 'lvce-editor.auth';
+const deleteSecret = async key => {
+  await invoke('SecretStorage.delete', authStorageId, key);
+};
+const getSecret = async key => {
+  const value = await invoke('SecretStorage.get', authStorageId, key);
+  return typeof value === 'string' ? value : '';
+};
+const storeSecret = async (key, value) => {
+  await invoke('SecretStorage.store', authStorageId, key, value);
 };
 
 const databaseName = 'auth-worker';
 const objectStoreName = 'auth';
 const memoryStorage = new Map();
+const secretKeys = new Set(['accessToken', 'refreshToken']);
 const state$1 = {
   databasePromise: undefined
 };
@@ -1183,7 +1217,7 @@ const getDatabase = async () => {
   }
   return state$1.databasePromise;
 };
-const getPersistentAuthValue = async key => {
+const getIndexedDbValue = async key => {
   const database = await getDatabase();
   if (!database) {
     return memoryStorage.get(key) ?? '';
@@ -1193,7 +1227,7 @@ const getPersistentAuthValue = async key => {
   const value = await requestToPromise(objectStore.get(key));
   return typeof value === 'string' ? value : '';
 };
-const setPersistentAuthValue = async (key, value) => {
+const setIndexedDbValue = async (key, value) => {
   memoryStorage.set(key, value);
   const database = await getDatabase();
   if (!database) {
@@ -1204,7 +1238,7 @@ const setPersistentAuthValue = async (key, value) => {
   objectStore.put(value, key);
   await transactionToPromise(transaction);
 };
-const clearPersistentAuthValue = async key => {
+const clearIndexedDbValue = async key => {
   memoryStorage.delete(key);
   const database = await getDatabase();
   if (!database) {
@@ -1215,6 +1249,44 @@ const clearPersistentAuthValue = async key => {
   objectStore.delete(key);
   await transactionToPromise(transaction);
 };
+const shouldUseSecretStorage = key => {
+  return getAuthPlatform() === Electron && secretKeys.has(key);
+};
+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;
+};
+const setPersistentAuthValue = async (key, value) => {
+  if (!shouldUseSecretStorage(key)) {
+    await setIndexedDbValue(key, value);
+    return;
+  }
+  if (value) {
+    await storeSecret(key, value);
+  } else {
+    await deleteSecret(key);
+  }
+  await clearIndexedDbValue(key);
+};
+const clearPersistentAuthValue = async key => {
+  if (shouldUseSecretStorage(key)) {
+    await Promise.all([deleteSecret(key), clearIndexedDbValue(key)]);
+    return;
+  }
+  await clearIndexedDbValue(key);
+};
 
 const callbackUrlKey = 'oidcCallbackUrl';
 const clientIdKey = 'oidcClientId';
@@ -2114,7 +2186,7 @@ const handleMessagePort = async (port, rpcId) => {
     messagePort: port
   });
   if (rpcId) {
-    set$2(rpcId, rpc);
+    set$3(rpcId, rpc);
   }
 };
 
@@ -2148,7 +2220,7 @@ const exchangeAuthorizationCode = async (backendUrl, clientId, code, redirectUri
 
 const getCurrentHref = async () => {
   try {
-    return await invoke('Layout.getHref');
+    return await invoke$1('Layout.getHref');
   } catch {
     // ignore
   }
@@ -2378,9 +2450,13 @@ const getBackendUrl = options => {
   }
   return options.backendUrl || '';
 };
+const getPlatform = options => {
+  return typeof options === 'number' ? options : options.platform ?? Web;
+};
 const initialize = async options => {
   const backendUrl = getBackendUrl(options);
   setAuthBackendUrl(backendUrl);
+  setAuthPlatform(getPlatform(options));
   try {
     if (backendUrl) {
       const completedBrowserLogin = await completeBrowserOidcLogin(backendUrl);
@@ -2854,7 +2930,7 @@ const errorHtml = `<!doctype html>
 </html>`;
 
 const getElectronRedirectUri = async uid => {
-  const localOauthServerPort = await invoke$2('OAuthServer.create', String(uid), successHtml, errorHtml);
+  const localOauthServerPort = await invoke$3('OAuthServer.create', String(uid), successHtml, errorHtml);
   return `http://localhost:${localOauthServerPort}/callback`;
 };
 
@@ -2957,7 +3033,7 @@ const hasAuthorizationCode = value => {
   return typeof value === 'string' && value.length > 0;
 };
 const getElectronAuthorizationCode = async uid => {
-  return invoke$2('OAuthServer.getCode', String(uid));
+  return invoke$3('OAuthServer.getCode', String(uid));
 };
 const waitForElectronBackendLogin = async (backendUrl, uid, redirectUri, codeVerifier, timeoutMs = 30_000, pollIntervalMs = 1000, getAuthorizationCode = getElectronAuthorizationCode, exchangeAuthorizationCode = exchangeElectronAuthorizationCode) => {
   const deadline = Date.now() + timeoutMs;
@@ -3018,7 +3094,7 @@ const getInteractiveLoginResult = async (backendUrl, platform, signingInState) =
       state
     });
   }
-  await invoke$1('Open.openUrl', loginUrl, platform, authUseRedirect);
+  await invoke$2('Open.openUrl', loginUrl, platform, authUseRedirect);
   if (platform !== Electron && authUseRedirect) {
     return signingInState;
   }
@@ -3036,6 +3112,7 @@ const handleClickLogin = async options => {
     backendUrl,
     platform
   } = options;
+  setAuthPlatform(platform);
   if (!backendUrl) {
     return {
       authErrorMessage: 'Backend URL is missing.',
@@ -3098,8 +3175,19 @@ const initializeRendererWorker = async () => {
   });
 };
 
+const sendMessagePortToSharedProcess = async port => {
+  await sendMessagePortToSharedProcess$1(port);
+};
+const initializeSharedProcess = async () => {
+  const rpc = await create$2({
+    commandMap: {},
+    send: sendMessagePortToSharedProcess
+  });
+  set(rpc);
+};
+
 const listen = async () => {
-  await Promise.all([initializeRendererWorker(), initializeOpenerWorker(), initializeAuthProcess()]);
+  await Promise.all([initializeRendererWorker(), initializeOpenerWorker(), initializeAuthProcess(), initializeSharedProcess()]);
 };
 
 const main = async () => {

package/package.json

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