@lvce-editor/auth-worker 3.5.1 → 3.7.0

package/dist/authWorkerMain.js

@@ -478,7 +478,10 @@ const constructError = (message, type, name) => {
   if (ErrorConstructor === Error) {
     const error = new Error(message);
     if (name && name !== 'VError') {
-      error.name = name;
+      Object.defineProperty(error, 'name', {
+        configurable: true,
+        value: name
+      });
     }
     return error;
   }
@@ -495,8 +498,10 @@ const getCurrentStack = () => {
   const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
+const getNewLineIndex = (string, startIndex) => {
+  {
+    return string.indexOf(NewLine);
+  }
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
@@ -507,55 +512,91 @@ const getParentStack = error => {
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
+const setStack = (error, stack) => {
+  const descriptor = Object.getOwnPropertyDescriptor(error, 'stack');
+  if (descriptor) {
+    if (!descriptor.configurable && !descriptor.writable) {
+      return;
+    }
+    if (!descriptor.configurable && descriptor.writable) {
+      error.stack = stack;
+      return;
+    }
+  }
+  Object.defineProperty(error, 'stack', {
+    configurable: true,
+    value: stack,
+    writable: true
+  });
+};
+const restoreExistingError = (error, currentStack) => {
+  if (typeof error.stack === 'string') {
+    setStack(error, `${error.stack}${NewLine}${currentStack}`);
+  }
+  return error;
+};
+const restoreMethodNotFoundError = (error, currentStack) => {
+  const restoredError = new JsonRpcError(error.message);
+  const parentStack = getParentStack(error);
+  setStack(restoredError, `${parentStack}${NewLine}${currentStack}`);
+  return restoredError;
+};
+const restoreStackFromData = (restoredError, error, currentStack) => {
+  if (error.data.stack && error.data.type && error.message) {
+    setStack(restoredError, `${error.data.type}: ${error.message}${NewLine}${error.data.stack}${NewLine}${currentStack}`);
+    return;
+  }
+  if (error.data.stack) {
+    setStack(restoredError, error.data.stack);
+  }
+};
+const applyDataProperties = (restoredError, error) => {
+  restoreStackFromData(restoredError, error, getCurrentStack());
+  if (error.data.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.data.codeFrame;
+  }
+  if (error.data.code) {
+    // @ts-ignore
+    restoredError.code = error.data.code;
+  }
+  if (error.data.type) {
+    // @ts-ignore
+    restoredError.name = error.data.type;
+  }
+};
+const applyDirectProperties = (restoredError, error) => {
+  if (error.stack) {
+    const lowerStack = restoredError.stack || '';
+    const indexNewLine = getNewLineIndex(lowerStack);
+    const parentStack = getParentStack(error);
+    // @ts-ignore
+    setStack(restoredError, `${parentStack}${lowerStack.slice(indexNewLine)}`);
+  }
+  if (error.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.codeFrame;
+  }
+};
+const restoreMessageError = (error, _currentStack) => {
+  const restoredError = constructError(error.message, error.type, error.name);
+  if (error.data) {
+    applyDataProperties(restoredError, error);
+  } else {
+    applyDirectProperties(restoredError, error);
+  }
+  return restoredError;
+};
 const restoreJsonRpcError = error => {
   const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
-    if (typeof error.stack === 'string') {
-      error.stack = error.stack + NewLine + currentStack;
-    }
-    return error;
+    return restoreExistingError(error, currentStack);
   }
   if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine + currentStack;
-    return restoredError;
+    return restoreMethodNotFoundError(error, currentStack);
   }
   if (error && error.message) {
-    const restoredError = constructError(error.message, error.type, error.name);
-    if (error.data) {
-      if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        // @ts-ignore
-        restoredError.name = error.data.type;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
-    }
-    return restoredError;
+    return restoreMessageError(error);
   }
   if (typeof error === 'string') {
     return new Error(`JsonRpc Error: ${error}`);
@@ -968,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 => {
@@ -1001,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);
@@ -1010,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');
@@ -1046,7 +1098,7 @@ const initializeAuthProcess = async () => {
     commandMap: {},
     send: sendMessagePortToAuthProcess
   });
-  set$1(rpc);
+  set$2(rpc);
 };
 
 const sendMessagePortToOpenerWorker = async port => {
@@ -1057,7 +1109,7 @@ const initializeOpenerWorker = async () => {
     commandMap: {},
     send: sendMessagePortToOpenerWorker
   });
-  set(rpc);
+  set$1(rpc);
 };
 
 const millisecondsPerSecond = 1000;
@@ -1075,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
 };
@@ -1142,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) ?? '';
@@ -1152,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) {
@@ -1163,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) {
@@ -1174,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';
@@ -2073,7 +2186,7 @@ const handleMessagePort = async (port, rpcId) => {
     messagePort: port
   });
   if (rpcId) {
-    set$2(rpcId, rpc);
+    set$3(rpcId, rpc);
   }
 };
 
@@ -2107,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
   }
@@ -2337,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);
@@ -2813,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`;
 };
 
@@ -2916,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;
@@ -2977,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;
   }
@@ -2995,6 +3112,7 @@ const handleClickLogin = async options => {
     backendUrl,
     platform
   } = options;
+  setAuthPlatform(platform);
   if (!backendUrl) {
     return {
       authErrorMessage: 'Backend URL is missing.',
@@ -3057,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.5.1",
+  "version": "3.7.0",
   "description": "Auth Worker",
   "repository": {
     "type": "git",