@bigio/better-auth-electron 1.0.4 → 1.0.5

package/dist/web.js

@@ -1,5 +1,5 @@
 import { useRef, useCallback, useSyncExternalStore } from 'react';
-import z from 'zod';
+import z, { boolean } from 'zod';
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -111,14 +111,19 @@ function useStore(store, { keys, deps = [store, keys] } = {}) {
   let get = () => snapshotRef.current;
   return useSyncExternalStore(subscribe, get, get);
 }
-var defatultWebOptions = {
+var defaultWebOptions = {
   ELECTRON_SCHEME: "bigio",
   SCHEME_NAME_IN_URL: "scheme",
   PROVIDERS: ["github", "google"],
   PROVIDER_NAME_IN_URL: "provider",
-  CHALLENGE_NAME_IN_URL: "electron_challenge",
+  CHALLENGE_NAME_IN_URL: "electron-challenge",
   WEB_OAUTH_SIGNIN_CALLBACK_PATHNAME: "electron-handoff",
-  BACKEND_FAST_TICKET_URL: "electron/fastTicket"
+  BACKEND_FAST_TICKET_URL: "electron/fastTicket",
+  SCOPES_NAME_IN_URL: "electron-scopes",
+  LOGINHINT_NAME_IN_URL: "electron-loginhint",
+  ADDITIONAL_DATA_NAME_IN_URL: "electron-addata",
+  REQUEST_SIGN_UP_NAME_IN_URL: "electron-reqsignup",
+  AUTH_STATUS_NAME_IN_URL: "electron-status"
 };
 
 // node_modules/.pnpm/@oslojs+encoding@1.1.0/node_modules/@oslojs/encoding/dist/base32.js
@@ -134,6 +139,52 @@ var DecodingPadding;
 })(DecodingPadding || (DecodingPadding = {}));
 
 // node_modules/.pnpm/@oslojs+encoding@1.1.0/node_modules/@oslojs/encoding/dist/base64.js
+function decodeBase64urlIgnorePadding(encoded) {
+  return decodeBase64_internal(encoded, base64urlDecodeMap, DecodingPadding2.Ignore);
+}
+function decodeBase64_internal(encoded, decodeMap, padding) {
+  const result = new Uint8Array(Math.ceil(encoded.length / 4) * 3);
+  let totalBytes = 0;
+  for (let i = 0; i < encoded.length; i += 4) {
+    let chunk = 0;
+    let bitsRead = 0;
+    for (let j = 0; j < 4; j++) {
+      if (padding === DecodingPadding2.Required && encoded[i + j] === "=") {
+        continue;
+      }
+      if (padding === DecodingPadding2.Ignore && (i + j >= encoded.length || encoded[i + j] === "=")) {
+        continue;
+      }
+      if (j > 0 && encoded[i + j - 1] === "=") {
+        throw new Error("Invalid padding");
+      }
+      if (!(encoded[i + j] in decodeMap)) {
+        throw new Error("Invalid character");
+      }
+      chunk |= decodeMap[encoded[i + j]] << (3 - j) * 6;
+      bitsRead += 6;
+    }
+    if (bitsRead < 24) {
+      let unused;
+      if (bitsRead === 12) {
+        unused = chunk & 65535;
+      } else if (bitsRead === 18) {
+        unused = chunk & 255;
+      } else {
+        throw new Error("Invalid padding");
+      }
+      if (unused !== 0) {
+        throw new Error("Invalid padding");
+      }
+    }
+    const byteLength = Math.floor(bitsRead / 8);
+    for (let i2 = 0; i2 < byteLength; i2++) {
+      result[totalBytes] = chunk >> 16 - i2 * 8 & 255;
+      totalBytes++;
+    }
+  }
+  return result.slice(0, totalBytes);
+}
 var EncodingPadding2;
 (function(EncodingPadding3) {
   EncodingPadding3[EncodingPadding3["Include"] = 0] = "Include";
@@ -144,6 +195,72 @@ var DecodingPadding2;
   DecodingPadding3[DecodingPadding3["Required"] = 0] = "Required";
   DecodingPadding3[DecodingPadding3["Ignore"] = 1] = "Ignore";
 })(DecodingPadding2 || (DecodingPadding2 = {}));
+var base64urlDecodeMap = {
+  "0": 52,
+  "1": 53,
+  "2": 54,
+  "3": 55,
+  "4": 56,
+  "5": 57,
+  "6": 58,
+  "7": 59,
+  "8": 60,
+  "9": 61,
+  A: 0,
+  B: 1,
+  C: 2,
+  D: 3,
+  E: 4,
+  F: 5,
+  G: 6,
+  H: 7,
+  I: 8,
+  J: 9,
+  K: 10,
+  L: 11,
+  M: 12,
+  N: 13,
+  O: 14,
+  P: 15,
+  Q: 16,
+  R: 17,
+  S: 18,
+  T: 19,
+  U: 20,
+  V: 21,
+  W: 22,
+  X: 23,
+  Y: 24,
+  Z: 25,
+  a: 26,
+  b: 27,
+  c: 28,
+  d: 29,
+  e: 30,
+  f: 31,
+  g: 32,
+  h: 33,
+  i: 34,
+  j: 35,
+  k: 36,
+  l: 37,
+  m: 38,
+  n: 39,
+  o: 40,
+  p: 41,
+  q: 42,
+  r: 43,
+  s: 44,
+  t: 45,
+  u: 46,
+  v: 47,
+  w: 48,
+  x: 49,
+  y: 50,
+  z: 51,
+  "-": 62,
+  _: 63
+};
 
 // src/utils/electron-plugin-env.ts
 var getGlobal = () => {
@@ -172,6 +289,7 @@ var getRawNodeEnv = () => {
   return "development";
 };
 var RAW_ENV = getRawNodeEnv();
+var IS_DEV = RAW_ENV === "development";
 var IS_ELECTRON_PACKAGED = (() => {
   if (typeof process !== "undefined" && process.versions && process.versions.electron) {
     try {
@@ -209,6 +327,34 @@ var BigIOError = class extends Error {
     };
   }
 };
+var consoleError = (originalError, message, bigioErrorStack) => {
+  if (!IS_DEV) {
+    return;
+  }
+  if (message && bigioErrorStack) {
+    console.groupCollapsed(`[BigIOError]`);
+    console.error("[BigIOError] message: ", message);
+    if (Array.isArray(bigioErrorStack) && bigioErrorStack.length > 0) {
+      console.log("[BigIOError] Stack Trace Table: ");
+      console.table(bigioErrorStack);
+    }
+    console.error("[BigIOError] Original Error: ", originalError);
+    console.groupEnd();
+  } else if (originalError instanceof BigIOError) {
+    console.groupCollapsed(`[BigIOError]`);
+    console.error("[BigIOError] message: ", originalError.message);
+    if (Array.isArray(originalError.bigioErrorStack) && originalError.bigioErrorStack.length > 0) {
+      console.log("[BigIOError] Stack Trace Table: ");
+      console.table(originalError.bigioErrorStack);
+    }
+    console.error("[BigIOError] Original Error: ", originalError.cause);
+    console.groupEnd();
+  } else {
+    console.groupCollapsed(`[Error]`);
+    console.error("[Error]: ", originalError);
+    console.groupEnd();
+  }
+};
 function getPreviousBigIOErrorStack(error) {
   if (error instanceof BigIOError) {
     return error.bigioErrorStack;
@@ -225,15 +371,41 @@ function okOr(value, errorMessage) {
   const now = Date.now();
   const ctx = (() => {
     const DEFAULT_CTX = "okOr function failed";
-    {
+    if (!(errorMessage instanceof Error) && typeof errorMessage === "object" && "ctx" in errorMessage) {
+      return errorMessage.ctx;
+    }
+    if (typeof errorMessage === "string") {
+      return DEFAULT_CTX;
+    }
+    if (errorMessage === void 0) {
+      return DEFAULT_CTX;
+    }
+    if (errorMessage instanceof Error) {
+      return DEFAULT_CTX;
+    }
+    if (errorMessage === true) {
       return DEFAULT_CTX;
     }
+    return DEFAULT_CTX;
   })();
   const msg = (() => {
     const DEFAULT_MSG = "Unexpected return null or undefined value";
-    {
+    if (!(errorMessage instanceof Error) && typeof errorMessage === "object" && "msg" in errorMessage && typeof errorMessage.msg === "string") {
+      return errorMessage.msg;
+    }
+    if (typeof errorMessage === "string") {
+      return errorMessage;
+    }
+    if (errorMessage === void 0) {
+      return DEFAULT_MSG;
+    }
+    if (errorMessage instanceof Error) {
+      return DEFAULT_MSG;
+    }
+    if (errorMessage === true) {
       return DEFAULT_MSG;
     }
+    return DEFAULT_MSG;
   })();
   const newItem = {
     msg,
@@ -275,6 +447,114 @@ function okOr(value, errorMessage) {
     bigioErrorStack: [newItem]
   });
 }
+var handleUnsafeError = (originalError, errorMessage) => {
+  const now = Date.now();
+  const prevStack = getPreviousBigIOErrorStack(originalError);
+  const originalErrorMsg = originalError instanceof Error ? originalError.message : String(originalError);
+  const newMsg = (() => {
+    if (errorMessage === true) {
+      return originalErrorMsg;
+    }
+    if (typeof errorMessage === "string") {
+      return errorMessage;
+    }
+    if (typeof errorMessage === "object" && "ctx" in errorMessage && !(errorMessage instanceof Error)) {
+      return errorMessage.msg || originalErrorMsg;
+    }
+    if (errorMessage instanceof Error) {
+      return errorMessage.message;
+    }
+    return originalErrorMsg;
+  })();
+  const userStack = (() => {
+    if (errorMessage === true) {
+      return [
+        {
+          msg: "SafeTry failed",
+          ctx: originalErrorMsg,
+          timestamp: now
+        }
+      ];
+    }
+    if (typeof errorMessage === "string") {
+      return [
+        {
+          msg: errorMessage,
+          ctx: originalErrorMsg,
+          timestamp: now
+        }
+      ];
+    }
+    if (typeof errorMessage === "object" && "ctx" in errorMessage && !(errorMessage instanceof Error)) {
+      return [
+        {
+          msg: errorMessage.msg || originalErrorMsg,
+          ctx: errorMessage.ctx,
+          timestamp: now
+        }
+      ];
+    }
+    if (errorMessage instanceof Error) {
+      const userNewStack = getPreviousBigIOErrorStack(errorMessage);
+      if (userNewStack.length > 0) {
+        const lastItem = userNewStack.at(-1);
+        if (lastItem && typeof lastItem === "object" && !("timestamp" in lastItem && lastItem.timestamp)) {
+          return [...userNewStack.slice(0, -1), { ...lastItem, timestamp: now }];
+        }
+        return userNewStack;
+      }
+      return [{ msg: errorMessage.message, ctx: originalErrorMsg, timestamp: now }];
+    }
+    return [{ ctx: originalErrorMsg }];
+  })();
+  const MAX_STACK_SIZE = IS_DEV ? 500 : 50;
+  const newStack = (() => {
+    const stack = [...prevStack, ...userStack];
+    if (stack.length > MAX_STACK_SIZE) {
+      return [
+        {
+          msg: `... Truncated (Stack > ${MAX_STACK_SIZE}) ...`,
+          ctx: null,
+          timestamp: now
+        },
+        ...stack.slice(-MAX_STACK_SIZE)
+      ];
+    }
+    return stack;
+  })();
+  consoleError(originalError, newMsg, newStack);
+  if (errorMessage instanceof Error) {
+    if (!errorMessage.cause && originalError) {
+      try {
+        Object.defineProperty(errorMessage, "cause", {
+          value: originalError,
+          configurable: true,
+          writable: true,
+          enumerable: false
+        });
+      } catch {
+      }
+    }
+    try {
+      Object.defineProperty(errorMessage, "bigioErrorStack", {
+        value: newStack,
+        configurable: true,
+        writable: true,
+        enumerable: false
+      });
+    } catch {
+      throw new BigIOError("Wrapper for frozen user error", {
+        cause: errorMessage,
+        bigioErrorStack: newStack
+      });
+    }
+    throw errorMessage;
+  }
+  throw new BigIOError(newMsg, {
+    cause: originalError,
+    bigioErrorStack: newStack
+  });
+};
 var handleSafeError = (originalError) => {
   const prevStack = getPreviousBigIOErrorStack(originalError);
   const originalErrorMsg = originalError instanceof Error ? originalError.message : String(originalError);
@@ -292,6 +572,9 @@ var handleSafeError = (originalError) => {
   };
 };
 var handlePromise = (internalPromise, errorMessage) => {
+  if (errorMessage !== void 0) {
+    return internalPromise.then((data) => okOr(data, errorMessage)).catch((originalError) => handleUnsafeError(originalError, errorMessage));
+  }
   return internalPromise.then((data) => ({ data: okOr(data), error: null })).catch((originalError) => handleSafeError(originalError));
 };
 function safeTry(func, errorMessage) {
@@ -304,13 +587,18 @@ function safeTry(func, errorMessage) {
       if (result instanceof Promise) {
         return handlePromise(result, errorMessage);
       }
-      if (errorMessage !== void 0) ;
+      if (errorMessage !== void 0) {
+        return okOr(result, errorMessage);
+      }
       return {
         data: okOr(result),
         error: null
       };
     }
   } catch (error) {
+    if (errorMessage !== void 0) {
+      handleUnsafeError(error, errorMessage);
+    }
     return handleSafeError(error);
   }
   const now = Date.now();
@@ -325,22 +613,67 @@ function safeTry(func, errorMessage) {
       }
     ]
   });
+  if (errorMessage !== void 0) {
+    throw invalidError;
+  }
   return {
     data: null,
     error: invalidError
   };
 }
 new TextEncoder();
+var GLOBAL_DECODER = new TextDecoder();
+function decode64(str) {
+  const checkStr = okOr(str, {
+    msg: "Invalid string input for fromBase64Url",
+    ctx: {
+      stringLength: str?.length
+    }
+  });
+  const normalizedStr = checkStr.replace(/\+/g, "-").replace(/\//g, "_");
+  const bytesBuffer = safeTry(() => decodeBase64urlIgnorePadding(normalizedStr), {
+    msg: "Base64 Decoding Failed",
+    ctx: {
+      msg: "Oslo decode failed",
+      ctx: { strPart: str.slice(0, 10) }
+    }
+  });
+  return bytesBuffer;
+}
 var REGEX_BASE64_URL = /^[a-zA-Z0-9\-_]+=*$/;
-function SearchParamsZod(ELECTRON_SCHEME, PROVIDERS) {
+function RequiredSearchParamsBuilder(ELECTRON_SCHEME, PROVIDERS) {
   return z.object({
     scheme: z.string().min(1, "Scheme cannot be empty").regex(REGEX_BASE64_URL).refine((scheme) => scheme === ELECTRON_SCHEME, {
       message: "Invalid scheme provided"
     }),
     provider: z.enum(PROVIDERS),
-    challenge: z.string().length(43, "Challenge must be exactly 43 characters").regex(REGEX_BASE64_URL)
+    challenge: z.string().length(43, "Challenge must be exactly 43 characters").regex(REGEX_BASE64_URL),
+    status: z.enum(["succeed", "error", "newUser"]).optional()
   });
 }
+var OptionalSearchParamsZodBuilder = z.object({
+  scopes: z.array(z.string()).optional(),
+  loginHint: z.string().optional(),
+  additionalData: z.record(z.string(), z.any()).optional(),
+  requestSignUp: boolean().optional()
+});
+var safeDecodeURL = (data) => {
+  return safeTry(() => {
+    if (data === void 0 || data === null) {
+      throw new BigIOError("Invalid input for safeDecodeURL: input is null/undefined", {
+        bigioErrorStack: [{ msg: "input is null/undefined" }]
+      });
+    }
+    if (typeof data !== "string") {
+      throw new BigIOError("Invalid input for safeDecodeURL: expected string", {
+        bigioErrorStack: [{ ctx: { type: typeof data, value: data } }]
+      });
+    }
+    const bytes = decode64(data);
+    const jsonStr = GLOBAL_DECODER.decode(bytes);
+    return JSON.parse(jsonStr);
+  }, true);
+};
 
 // src/web/electron-web-clientHelper.ts
 var lazyClient = atom();
@@ -357,7 +690,7 @@ var checkAndSetGlobalLock = () => {
   return false;
 };
 var electronWebHandoffPlugin = () => {
-  const config = { ...defatultWebOptions };
+  const config = { ...defaultWebOptions };
   const {
     CHALLENGE_NAME_IN_URL,
     PROVIDER_NAME_IN_URL,
@@ -365,16 +698,23 @@ var electronWebHandoffPlugin = () => {
     PROVIDERS,
     ELECTRON_SCHEME,
     WEB_OAUTH_SIGNIN_CALLBACK_PATHNAME,
-    BACKEND_FAST_TICKET_URL
+    BACKEND_FAST_TICKET_URL,
+    SCOPES_NAME_IN_URL,
+    LOGINHINT_NAME_IN_URL,
+    ADDITIONAL_DATA_NAME_IN_URL,
+    REQUEST_SIGN_UP_NAME_IN_URL,
+    AUTH_STATUS_NAME_IN_URL
   } = config;
   const electronWebAtoms = ($fetch) => {
     const handoffError = atom(null);
     const handoffStatus = atom("idle");
     const fastLogin = atom(null);
+    const initializationErrorAtom = atom(null);
     return {
       handoffError,
       handoffStatus,
-      fastLogin
+      fastLogin,
+      initializationErrorAtom
     };
   };
   return {
@@ -382,152 +722,208 @@ var electronWebHandoffPlugin = () => {
     getAtoms: ($fetch) => electronWebAtoms(),
     getActions: ($fetch, $store) => {
       const sessionAtom = $store.atoms.session;
-      const { handoffStatus, handoffError, fastLogin } = $store.atoms;
-      const handoffLogic = () => {
+      const {
+        handoffStatus,
+        handoffError,
+        fastLogin: fastLoginAtom,
+        initializationErrorAtom
+      } = $store.atoms;
+      const handoffLogic = async () => {
         if (handoffStatus.get() !== "idle" && handoffStatus.get() !== "pending") {
-          return;
+          return false;
         }
         const { data: sessionData, isPending, isRefetching, error } = sessionAtom.get();
         if (isPending || isRefetching || error) {
-          return;
+          return false;
         }
         const searchParams = new URLSearchParams(window.location.search);
         const scheme = searchParams.get(SCHEME_NAME_IN_URL);
         if (!scheme) {
-          return;
+          return false;
         }
         if (scheme !== ELECTRON_SCHEME) {
-          handoffStatus.set("failed");
-          handoffError.set(`Wrong Scheme: ${scheme}`);
-          return;
+          throw new BigIOError(`Wrong Scheme: ${scheme}`, {
+            bigioErrorStack: [
+              {
+                msg: `Wrong Scheme: ${scheme}`
+              }
+            ]
+          });
         }
         const provider = searchParams.get(PROVIDER_NAME_IN_URL);
+        if (!provider) {
+          return false;
+        }
         const challenge = searchParams.get(CHALLENGE_NAME_IN_URL);
-        const searchParamsZod = SearchParamsZod(ELECTRON_SCHEME, [...PROVIDERS]);
-        const searchParamsObj = {
+        if (!challenge) {
+          return false;
+        }
+        const SearchParamsZod = RequiredSearchParamsBuilder(ELECTRON_SCHEME, [...PROVIDERS]);
+        const requiredValidParams = SearchParamsZod.parse({
           scheme,
           provider,
           challenge
-        };
-        const validParams = searchParamsZod.parse(searchParamsObj);
+        });
+        const scopes = searchParams.get(SCOPES_NAME_IN_URL);
+        const loginHint = searchParams.get(LOGINHINT_NAME_IN_URL);
+        const additionalData = searchParams.get(ADDITIONAL_DATA_NAME_IN_URL);
+        const requestSignUp = searchParams.get(REQUEST_SIGN_UP_NAME_IN_URL);
+        const optionalValidParams = OptionalSearchParamsZodBuilder.parse({
+          scopes: scopes ? safeDecodeURL(scopes) : void 0,
+          loginHint: loginHint ? safeDecodeURL(loginHint) : void 0,
+          additionalData: additionalData ? safeDecodeURL(additionalData) : void 0,
+          requestSignUp: requestSignUp ? safeDecodeURL(requestSignUp) : void 0
+        });
         const client = lazyClient.get();
         if (!client) {
-          return;
+          throw new BigIOError("handoff fn faild to get AuthClient", {
+            bigioErrorStack: [{ msg: "check the init authClient code" }]
+          });
         }
-        const performFastLogin = async () => {
+        const fastLogin = async () => {
           handoffStatus.set("connecting");
-          const { data: fastLoginResult, error: fastLoginError } = await safeTry(
-            async () => {
-              const { data: fastTicketData, error: fastTicketError } = await client.$fetch(`/${BACKEND_FAST_TICKET_URL}`, {
-                method: "POST",
-                body: {
-                  userid: (sessionData?.user).id,
-                  scheme,
-                  provider,
-                  challenge
-                },
-                credentials: "include"
+          return await safeTry(async () => {
+            const { data: fastTicketData, error: fastTicketError } = await client.$fetch(`/${BACKEND_FAST_TICKET_URL}`, {
+              method: "POST",
+              body: {
+                userid: (sessionData?.user).id,
+                scheme,
+                provider,
+                challenge
+              },
+              credentials: "include"
+            });
+            if (fastTicketError || !fastTicketData.redirect) {
+              throw new BigIOError("Failed to get fast ticket", {
+                bigioErrorStack: [
+                  {
+                    msg: "Failed to get fast ticket",
+                    ctx: {
+                      requiredValidParams,
+                      error: fastTicketError
+                    }
+                  }
+                ]
               });
-              if (fastTicketError || !fastTicketData.redirect) {
-                handoffStatus.set("failed");
-                throw new BigIOError("Failed to get fast ticket", {
+            }
+            const targetUrl = fastTicketData.redirect;
+            if (!targetUrl.startsWith(`${scheme}://`)) {
+              throw new BigIOError(
+                `Failed to get fast ticket with Wrong Scheme: ${scheme}`,
+                {
                   bigioErrorStack: [
-                    { msg: "Failed to get fast ticket", ctx: validParams }
+                    {
+                      msg: "Failed to get fast ticket with Wrong Scheme",
+                      ctx: scheme
+                    }
                   ]
-                });
-              }
-              const targetUrl = fastTicketData.redirect;
-              if (!targetUrl.startsWith(`${scheme}://`)) {
-                handoffStatus.set("failed");
-                throw new BigIOError(
-                  `Failed to get fast ticket with Wrong Scheme: ${scheme}`,
-                  {
-                    bigioErrorStack: [
-                      {
-                        msg: "Failed to get fast ticket with Wrong Scheme",
-                        ctx: scheme
-                      }
-                    ]
-                  }
-                );
-              }
-              return fastTicketData;
+                }
+              );
             }
+            handoffStatus.set("succeed");
+            window.location.href = targetUrl;
+            return sessionData.user;
+          }, true);
+        };
+        const parseURL = (status) => {
+          const callbackURL = new URL(
+            `/${WEB_OAUTH_SIGNIN_CALLBACK_PATHNAME}`,
+            window.location.origin
           );
-          if (!fastLoginResult || fastLoginError) {
-            handoffStatus.set("failed");
-            handoffError.set("Can not perform fast login");
-            return false;
-          }
-          window.location.href = fastLoginResult.redirect;
-          handoffStatus.set("succeed");
-          return true;
+          callbackURL.searchParams.set(AUTH_STATUS_NAME_IN_URL, status);
+          callbackURL.searchParams.set(SCHEME_NAME_IN_URL, requiredValidParams.scheme);
+          callbackURL.searchParams.set(PROVIDER_NAME_IN_URL, requiredValidParams.provider);
+          callbackURL.searchParams.set(
+            CHALLENGE_NAME_IN_URL,
+            requiredValidParams.challenge
+          );
+          return callbackURL.pathname + callbackURL.search;
         };
-        const handleLogin = async (loginProvider) => {
+        const regularLogin = async (loginProvider) => {
           handoffStatus.set("connecting");
-          const { data: loginData, error: loginError } = await safeTry(async () => {
-            const callbackURL = new URL(
-              `/${WEB_OAUTH_SIGNIN_CALLBACK_PATHNAME}`,
-              window.location.origin
+          return await safeTry(async () => {
+            const { data: socialData, error: socialError } = await client.signIn.social(
+              {
+                provider: loginProvider,
+                callbackURL: parseURL("succeed"),
+                scopes: optionalValidParams.scopes,
+                additionalData: optionalValidParams.additionalData,
+                loginHint: optionalValidParams.loginHint,
+                requestSignUp: optionalValidParams.requestSignUp,
+                disableRedirect: false,
+                errorCallbackURL: parseURL("error"),
+                newUserCallbackURL: parseURL("newUser")
+              }
             );
-            callbackURL.searchParams.set(SCHEME_NAME_IN_URL, validParams.scheme);
-            callbackURL.searchParams.set(PROVIDER_NAME_IN_URL, validParams.provider);
-            callbackURL.searchParams.set(CHALLENGE_NAME_IN_URL, validParams.challenge);
-            const relativeCallbackURL = callbackURL.pathname + callbackURL.search;
-            const social = await client.signIn.social({
-              provider: loginProvider,
-              callbackURL: relativeCallbackURL
-              // additionalData
-              // disableRedirect
-              // errorCallbackURL
-              // fetchOptions
-              // idToken
-              // loginHint
-              // newUserCallbackURL
-              // requestSignUp
-              // scopes
-            });
-            return social;
-          });
-          if (!loginData || loginError) {
-            handoffStatus.set("failed");
-            handoffError.set("Failed to perform oauth login");
-            return false;
-          }
-          handoffStatus.set("succeed");
-          return true;
+            if (!socialData || socialError) {
+              throw new BigIOError(`Faild to sign in with ${loginProvider}`, {
+                bigioErrorStack: [
+                  {
+                    ctx: {
+                      provider: loginProvider,
+                      error: socialError
+                    }
+                  }
+                ]
+              });
+            }
+            handoffStatus.set("succeed");
+            return socialData;
+          }, true);
         };
-        if (sessionData.session) {
-          const isFastLogin = fastLogin.get();
+        if (sessionData?.session) {
+          if (optionalValidParams.requestSignUp) {
+            return await regularLogin(provider);
+          }
+          const isFastLogin = fastLoginAtom.get();
           if (isFastLogin === true) {
-            performFastLogin();
+            return await fastLogin();
           }
           if (isFastLogin === false) {
-            handleLogin(provider);
+            return await regularLogin(provider);
           }
           if (isFastLogin === null) {
             handoffStatus.set("pending");
-            return;
+            return true;
           }
         } else {
-          handleLogin(provider);
+          return await regularLogin(provider);
         }
+        return false;
       };
       if (!checkAndSetGlobalLock()) {
-        sessionAtom.listen((aatom) => {
-          handoffLogic();
+        sessionAtom.listen(async (aatom) => {
+          console.log(sessionAtom.get());
+          const { data, error } = await safeTry(() => handoffLogic());
+          if (error) {
+            handoffStatus.set("failed");
+            handoffError.set(error.message);
+            initializationErrorAtom.set(error);
+            console.error(error);
+          }
         });
-        fastLogin.listen(() => {
+        fastLoginAtom.listen(async () => {
           handoffStatus.set("idle");
-          handoffLogic();
+          const { data, error } = await safeTry(() => handoffLogic());
+          if (error) {
+            handoffStatus.set("failed");
+            handoffError.set(error.message);
+            initializationErrorAtom.set(error);
+            console.error(error);
+          }
         });
       }
       const setFastLogin = (decision) => {
-        fastLogin.set(decision);
+        fastLoginAtom.set(decision);
       };
       return {
         bigio: {
           useElectronOAuthSession: () => {
+            const initializationError = initializationErrorAtom.get();
+            if (initializationError instanceof Error) {
+              console.error(initializationError);
+              initializationErrorAtom.set(null);
+            }
             const { data, error, isPending, isRefetching, refetch } = useStore(sessionAtom);
             const oauthError = useStore(handoffError);
             const oauthStatus = useStore(handoffStatus);