@lvce-editor/auth-worker 1.3.0 → 1.5.0

package/dist/authWorkerMain.js

@@ -407,6 +407,100 @@ const IpcChildWithModuleWorkerAndMessagePort$1 = {
   listen: listen$6,
   wrap: wrap$e
 };
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        event,
+        type
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const Message$1 = 3;
+const create$5$1 = async ({
+  isMessagePortOpen,
+  messagePort
+}) => {
+  if (!isMessagePort(messagePort)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  if (isMessagePortOpen) {
+    return messagePort;
+  }
+  const eventPromise = getFirstEvent(messagePort, {
+    message: Message$1
+  });
+  messagePort.start();
+  const {
+    event,
+    type
+  } = await eventPromise;
+  if (type !== Message$1) {
+    throw new IpcError('Failed to wait for ipc message');
+  }
+  if (event.data !== readyMessage) {
+    throw new IpcError('unexpected first message');
+  }
+  return messagePort;
+};
+const signal$1 = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort extends Ipc {
+  getData = getData$2;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+  onClose(callback) {}
+}
+const wrap$5 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+const IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$5$1,
+  signal: signal$1,
+  wrap: wrap$5
+};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -643,7 +737,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$6 = (message, result) => {
+const create$9 = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$1,
@@ -652,7 +746,7 @@ const create$6 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$6(message, resultProperty);
+  return create$9(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -746,7 +840,7 @@ const handleJsonRpcMessage = async (...args) => {
 
 const Two = '2.0';
 
-const create$5 = (method, params) => {
+const create$8 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -754,7 +848,7 @@ const create$5 = (method, params) => {
   };
 };
 
-const create$4 = (id, method, params) => {
+const create$7 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -765,12 +859,12 @@ const create$4 = (id, method, params) => {
 };
 
 let id = 0;
-const create$3 = () => {
+const create$6 = () => {
   return ++id;
 };
 
 const registerPromise = map => {
-  const id = create$3();
+  const id = create$6();
   const {
     promise,
     resolve
@@ -787,7 +881,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$4(id, method, params);
+  const message = create$7(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -823,7 +917,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$5(method, params);
+      const message = create$8(method, params);
       ipc.send(message);
     }
   };
@@ -863,6 +957,83 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
+const create$5 = async ({
+  commandMap,
+  isMessagePortOpen = true,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    isMessagePortOpen,
+    messagePort
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+
+const create$4 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$5({
+    commandMap,
+    isMessagePortOpen,
+    messagePort: port2
+  });
+};
+
+const createSharedLazyRpc = factory => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
+    }
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
+};
+
+const create$3 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$4({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
+  });
+};
+
 const create$2 = async ({
   commandMap,
   messagePort
@@ -909,7 +1080,7 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$1 = (id, rpc) => {
+const set$2 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
@@ -942,7 +1113,7 @@ const create = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$1(rpcId, mockRpc);
+      set$2(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -951,23 +1122,41 @@ const create = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$1(rpcId, rpc);
+      set$2(rpcId, rpc);
     }
   };
 };
 
+const Electron = 2;
+
 const OpenerWorker = 4561;
 const RendererWorker = 1;
 
 const {
-  invoke} = create(OpenerWorker);
-const openUrl = async (url, platform) => {
-  return invoke('Open.openUrl', url, platform);
-};
+  invoke: invoke$1,
+  set: set$1
+} = create(OpenerWorker);
 
 const {
+  invoke,
+  invokeAndTransfer,
   set
 } = create(RendererWorker);
+const sendMessagePortToOpenerWorker$1 = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToOpenerWorker', port, command, rpcId);
+};
+
+const sendMessagePortToOpenerWorker = async port => {
+  await sendMessagePortToOpenerWorker$1(port, 0);
+};
+const initializeOpenerWorker = async () => {
+  const rpc = await create$3({
+    commandMap: {},
+    send: sendMessagePortToOpenerWorker
+  });
+  set$1(rpc);
+};
 
 const handleMessagePort = async port => {
   await create$2({
@@ -989,10 +1178,6 @@ const getBackendAuthUrl = (backendUrl, path) => {
   return `${trimTrailingSlashes(backendUrl)}${path}`;
 };
 
-const getBackendLoginUrl = backendUrl => {
-  return getBackendAuthUrl(backendUrl, '/auth/login');
-};
-
 const getLoggedOutBackendAuthState = (authErrorMessage = '') => {
   return {
     authAccessToken: '',
@@ -1170,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 {
@@ -1190,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,
@@ -1222,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
     };
@@ -1271,7 +1546,7 @@ const initializeRendererWorker = async () => {
 };
 
 const listen = async () => {
-  await initializeRendererWorker();
+  await Promise.all([initializeRendererWorker(), initializeOpenerWorker()]);
 };
 
 const main = async () => {

package/package.json

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