@lvce-editor/auth-worker 1.4.0 → 1.5.0

package/dist/authWorkerMain.js

@@ -1127,18 +1127,18 @@ const create = rpcId => {
   };
 };
 
+const Electron = 2;
+
 const OpenerWorker = 4561;
 const RendererWorker = 1;
 
 const {
-  invoke,
+  invoke: invoke$1,
   set: set$1
 } = create(OpenerWorker);
-const openUrl = async (url, platform) => {
-  return invoke('Open.openUrl', url, platform);
-};
 
 const {
+  invoke,
   invokeAndTransfer,
   set
 } = create(RendererWorker);
@@ -1178,10 +1178,6 @@ const getBackendAuthUrl = (backendUrl, path) => {
   return `${trimTrailingSlashes(backendUrl)}${path}`;
 };
 
-const getBackendLoginUrl = backendUrl => {
-  return getBackendAuthUrl(backendUrl, '/auth/login');
-};
-
 const getLoggedOutBackendAuthState = (authErrorMessage = '') => {
   return {
     authAccessToken: '',
@@ -1359,6 +1355,38 @@ const waitForBackendLogin = async (backendUrl, timeoutMs = 30_000, pollIntervalM
   return getLoggedOutBackendAuthState(lastErrorMessage);
 };
 
+const getCurrentHref = async () => {
+  try {
+    return await invoke('Layout.getHref');
+  } catch {
+    // ignore
+  }
+  if (!globalThis.location || typeof globalThis.location.href !== 'string' || !globalThis.location.href) {
+    return '';
+  }
+  return globalThis.location.href;
+};
+const getEffectiveRedirectUri = async (platform, uid, redirectUri) => {
+  if (redirectUri) {
+    return redirectUri;
+  }
+  if (platform === Electron) {
+    return `http://localhost:${await invoke('OAuthServer.create', String(uid))}`;
+  }
+  return getCurrentHref();
+};
+const getBackendLoginRequest = async (backendUrl, platform = 0, uid = 0, redirectUri = '') => {
+  const loginUrl = new URL(getBackendAuthUrl(backendUrl, '/login'));
+  const effectiveRedirectUri = await getEffectiveRedirectUri(platform, uid, redirectUri);
+  if (effectiveRedirectUri) {
+    loginUrl.searchParams.set('redirect_uri', effectiveRedirectUri);
+  }
+  return {
+    loginUrl: loginUrl.toString(),
+    redirectUri: effectiveRedirectUri
+  };
+};
+
 const getLoggedInState = (state, response) => {
   const accessToken = typeof response.accessToken === 'string' ? response.accessToken : '';
   return {
@@ -1379,6 +1407,58 @@ const isLoginResponse = value => {
   return true;
 };
 
+const getBackendNativeExchangeUrl = backendUrl => {
+  return getBackendAuthUrl(backendUrl, '/auth/native/exchange');
+};
+
+const getExchangeErrorMessage = async response => {
+  try {
+    const payload = await response.json();
+    if (payload && typeof payload === 'object' && typeof payload.error === 'string' && payload.error) {
+      return payload.error;
+    }
+  } catch {
+    // ignore
+  }
+  return 'Backend authentication failed.';
+};
+const exchangeElectronAuthorizationCode = async (backendUrl, code, redirectUri) => {
+  const response = await fetch(getBackendNativeExchangeUrl(backendUrl), {
+    body: JSON.stringify({
+      code,
+      redirectUri
+    }),
+    credentials: 'include',
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json'
+    },
+    method: 'POST'
+  });
+  if (!response.ok) {
+    throw new Error(await getExchangeErrorMessage(response));
+  }
+};
+
+const hasAuthorizationCode = value => {
+  return typeof value === 'string' && value.length > 0;
+};
+const waitForElectronBackendLogin = async (backendUrl, uid, redirectUri, timeoutMs = 30_000, pollIntervalMs = 1000) => {
+  const started = Date.now();
+  const deadline = started + timeoutMs;
+  while (Date.now() < deadline) {
+    const authorizationCode = await invoke('OAuthServer.getCode', String(uid));
+    if (hasAuthorizationCode(authorizationCode)) {
+      const elapsed = Date.now() - started;
+      const remainingTime = Math.max(0, timeoutMs - elapsed);
+      await exchangeElectronAuthorizationCode(backendUrl, authorizationCode, redirectUri);
+      return waitForBackendLogin(backendUrl, remainingTime, pollIntervalMs);
+    }
+    await delay(pollIntervalMs);
+  }
+  return getLoggedOutBackendAuthState('Timed out waiting for backend login.');
+};
+
 const handleClickLogin = async options => {
   const {
     backendUrl,
@@ -1411,8 +1491,14 @@ const handleClickLogin = async options => {
       }
       return getLoggedInState(signingInState, response);
     }
-    await openUrl(getBackendLoginUrl(backendUrl), platform);
-    const authState = await waitForBackendLogin(backendUrl);
+    const uid = 0;
+    const {
+      loginUrl,
+      redirectUri
+    } = await getBackendLoginRequest(backendUrl, platform, uid);
+    const authUseRedirect = false;
+    await invoke$1('Open.openUrl', loginUrl, platform, authUseRedirect);
+    const authState = platform === Electron ? await waitForElectronBackendLogin(backendUrl, uid, redirectUri) : await waitForBackendLogin(backendUrl);
     return {
       ...authState
     };

package/package.json

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