@arbidocs/client 0.4.1 → 0.4.3

package/dist/index.cjs

@@ -392,6 +392,21 @@ function createBearerAuthMiddleware(config) {
 }
 
 // src/middleware/auto-relogin.ts
+var NO_ACTIVE_WORKSPACE = /no active workspace/i;
+async function isNoActiveWorkspace(response) {
+  try {
+    return NO_ACTIVE_WORKSPACE.test(await response.clone().text());
+  } catch {
+    return false;
+  }
+}
+function safeClone(request) {
+  try {
+    return request.clone();
+  } catch {
+    return null;
+  }
+}
 function createAutoReloginMiddleware(config) {
   const cloneCache = /* @__PURE__ */ new WeakMap();
   return {
@@ -402,6 +417,25 @@ function createAutoReloginMiddleware(config) {
       }
     },
     async onResponse({ response, request }) {
+      if (response.status === 400 && await isNoActiveWorkspace(response)) {
+        let token = null;
+        let recovered = await config.reopenWorkspaceHandler?.() ?? false;
+        if (!recovered) {
+          token = await config.reloginHandler();
+          recovered = token !== null;
+        }
+        if (!recovered) {
+          config.onReloginFailed?.();
+          return response;
+        }
+        const retry = cloneCache.get(request) ?? safeClone(request);
+        if (retry) {
+          if (token) retry.headers.set("Authorization", `Bearer ${token}`);
+          return fetch(retry);
+        }
+        config.onRetryCloneFailed?.();
+        return response;
+      }
       if (response.status === 400) {
         const isSafeMethod = ["GET", "HEAD", "DELETE"].includes(request.method);
         if (isSafeMethod) {
@@ -562,6 +596,47 @@ function createReloginHandler(deps) {
   };
 }
 
+// src/relogin/reopen.ts
+function createWorkspaceReopener(deps) {
+  let inFlight = null;
+  return function reopenWorkspace() {
+    if (inFlight) return inFlight;
+    inFlight = (async () => {
+      try {
+        const workspaceId = deps.authState.getSelectedWorkspaceId();
+        const accessToken = deps.getAccessToken();
+        if (!workspaceId || !accessToken) return false;
+        const session = await deps.sessionStorage.getSession();
+        if (!session?.signingPrivateKey || !session.serverSessionKey) return false;
+        await deps.crypto.ensureReady();
+        const wrappedKey = await deps.workspaceKeyRefreshProvider.getWrappedKey(
+          accessToken,
+          workspaceId
+        );
+        if (!wrappedKey) return false;
+        const encryptionKeyPair = deps.crypto.deriveEncryptionKeypair({
+          publicKey: session.signingPrivateKey.slice(32, 64),
+          secretKey: session.signingPrivateKey
+        });
+        const workspaceKey = deps.crypto.sealedBoxDecrypt(wrappedKey, encryptionKeyPair.secretKey);
+        const sealed = await deps.crypto.sealKeyForSession(workspaceKey, session.serverSessionKey);
+        const opened = await deps.workspaceOpenProvider.openWorkspace(
+          accessToken,
+          workspaceId,
+          sealed
+        );
+        return opened === true;
+      } catch (error) {
+        console.error("[API] Failed to re-open workspace:", error);
+        return false;
+      } finally {
+        inFlight = null;
+      }
+    })();
+    return inFlight;
+  };
+}
+
 // src/storage/indexed-db.ts
 var DB_NAME = "arbi-crypto";
 var DB_VERSION = 2;
@@ -1009,6 +1084,7 @@ function createArbiClient(options) {
     credentials = "include",
     ssoTokenProvider = null,
     onReloginSuccess,
+    onSessionExpired,
     sessionStorage: sessionStorageOverride,
     userEmail
   } = options;
@@ -1029,6 +1105,7 @@ function createArbiClient(options) {
     sealKeyForSession,
     fromBase64: base64ToBytes
   };
+  let reloginUnreachable = false;
   const loginProvider = {
     async login(payload) {
       const rawFetch = createFetchClient__default.default({
@@ -1036,14 +1113,21 @@ function createArbiClient(options) {
         credentials,
         fetch: retryFetch
       });
-      const response = await rawFetch.POST("/v1/user/login", {
-        body: {
-          email: payload.email,
-          signature: payload.signature,
-          timestamp: payload.timestamp,
-          sso_token: payload.ssoToken
-        }
-      });
+      let response;
+      try {
+        response = await rawFetch.POST("/v1/user/login", {
+          body: {
+            email: payload.email,
+            signature: payload.signature,
+            timestamp: payload.timestamp,
+            sso_token: payload.ssoToken
+          }
+        });
+      } catch (error) {
+        console.warn("[API] Login call unreachable:", error);
+        reloginUnreachable = true;
+        return null;
+      }
       if (response.error || !response.data) {
         console.warn("[API] Login call failed:", response.error);
         return null;
@@ -1074,15 +1158,46 @@ function createArbiClient(options) {
       return workspace?.wrapped_key ?? null;
     }
   };
-  const reloginHandler = createReloginHandler({
+  const workspaceOpenProvider = {
+    async openWorkspace(accessToken, workspaceId, encryptedWorkspaceKey) {
+      try {
+        const response = await retryFetch(`${baseUrl}${API_PREFIX}/workspace/${workspaceId}/open`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({ workspace_key: encryptedWorkspaceKey }),
+          credentials
+        });
+        return response.ok ? true : null;
+      } catch {
+        return null;
+      }
+    }
+  };
+  const rawReloginHandler = createReloginHandler({
     crypto: cryptoProvider,
     sessionStorage,
     authState,
     ssoTokenProvider,
     loginProvider,
     workspaceKeyRefreshProvider,
+    workspaceOpenProvider,
     onReloginSuccess
   });
+  const reloginHandler = () => {
+    reloginUnreachable = false;
+    return rawReloginHandler();
+  };
+  const reopenWorkspace = createWorkspaceReopener({
+    crypto: cryptoProvider,
+    sessionStorage,
+    authState,
+    getAccessToken: () => session.getState().accessToken,
+    workspaceKeyRefreshProvider,
+    workspaceOpenProvider
+  });
   const fetchClient = createFetchClient__default.default({
     baseUrl,
     credentials,
@@ -1092,7 +1207,11 @@ function createArbiClient(options) {
   fetchClient.use(
     createAutoReloginMiddleware({
       reloginHandler,
-      reloginExcludePatterns
+      reloginExcludePatterns,
+      reopenWorkspaceHandler: reopenWorkspace,
+      onReloginFailed: () => {
+        if (!reloginUnreachable && session.getState().userEmail) onSessionExpired?.();
+      }
     })
   );
   const authDeps = {
@@ -1109,7 +1228,8 @@ function createArbiClient(options) {
       loginWithKey: (params) => loginWithKey(params, authDeps),
       logout: () => logout(session),
       changePassword: (params) => changePassword(params, authDeps),
-      relogin: reloginHandler
+      relogin: reloginHandler,
+      reopenWorkspace
     },
     crypto: {
       initSodium,
@@ -1179,6 +1299,7 @@ exports.createBearerAuthMiddleware = createBearerAuthMiddleware;
 exports.createContentHash = createContentHash;
 exports.createReloginHandler = createReloginHandler;
 exports.createSessionManager = createSessionManager;
+exports.createWorkspaceReopener = createWorkspaceReopener;
 exports.decryptFile = decryptFile;
 exports.decryptMessage = decryptMessage;
 exports.decryptMessageWithSharedSecret = decryptMessageWithSharedSecret;