@reverbia/sdk 1.0.0-next.20251218225706 → 1.0.0-next.20251219154503

package/dist/react/index.mjs

@@ -2995,6 +2995,36 @@ var postApiV1Search = (options) => {
     }
   });
 };
+var postAuthOauthByProviderExchange = (options) => {
+  return (options.client ?? client).post({
+    url: "/auth/oauth/{provider}/exchange",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
+var postAuthOauthByProviderRefresh = (options) => {
+  return (options.client ?? client).post({
+    url: "/auth/oauth/{provider}/refresh",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
+var postAuthOauthByProviderRevoke = (options) => {
+  return (options.client ?? client).post({
+    url: "/auth/oauth/{provider}/revoke",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
 
 // src/lib/memory/constants.ts
 var DEFAULT_LOCAL_EMBEDDING_MODEL = "Snowflake/snowflake-arctic-embed-xs";
@@ -4545,116 +4575,196 @@ import {
   useState as useState10
 } from "react";
 
-// src/lib/backup/dropbox/auth.ts
-var DROPBOX_AUTH_URL = "https://www.dropbox.com/oauth2/authorize";
-var DROPBOX_TOKEN_URL = "https://api.dropboxapi.com/oauth2/token";
-var TOKEN_STORAGE_KEY = "dropbox_access_token";
-var VERIFIER_STORAGE_KEY = "dropbox_code_verifier";
-function generateCodeVerifier() {
-  const array = new Uint8Array(32);
-  crypto.getRandomValues(array);
-  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-async function generateCodeChallenge(verifier) {
-  const encoder = new TextEncoder();
-  const data = encoder.encode(verifier);
-  const hash = await crypto.subtle.digest("SHA-256", data);
-  const base64 = btoa(String.fromCharCode(...new Uint8Array(hash)));
-  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+// src/lib/backup/oauth/storage.ts
+var STORAGE_KEY_PREFIX = "oauth_token_";
+function getStorageKey2(provider) {
+  return `${STORAGE_KEY_PREFIX}${provider}`;
 }
-function getStoredToken() {
+function getStoredTokenData(provider) {
   if (typeof window === "undefined") return null;
-  return sessionStorage.getItem(TOKEN_STORAGE_KEY);
+  try {
+    const stored = localStorage.getItem(getStorageKey2(provider));
+    if (!stored) return null;
+    const data = JSON.parse(stored);
+    if (!data.accessToken) return null;
+    return data;
+  } catch {
+    return null;
+  }
 }
-function storeToken(token) {
+function storeTokenData(provider, data) {
   if (typeof window === "undefined") return;
-  sessionStorage.setItem(TOKEN_STORAGE_KEY, token);
+  localStorage.setItem(getStorageKey2(provider), JSON.stringify(data));
 }
-function clearToken() {
+function clearTokenData(provider) {
   if (typeof window === "undefined") return;
-  sessionStorage.removeItem(TOKEN_STORAGE_KEY);
+  localStorage.removeItem(getStorageKey2(provider));
 }
-function getStoredVerifier() {
-  if (typeof window === "undefined") return null;
-  return sessionStorage.getItem(VERIFIER_STORAGE_KEY);
+function isTokenExpired(data, bufferSeconds = 60) {
+  if (!data) return true;
+  if (!data.expiresAt) return false;
+  const now = Date.now();
+  const bufferMs = bufferSeconds * 1e3;
+  return data.expiresAt - bufferMs <= now;
 }
-function storeVerifier(verifier) {
-  if (typeof window === "undefined") return;
-  sessionStorage.setItem(VERIFIER_STORAGE_KEY, verifier);
+function getValidAccessToken(provider) {
+  const data = getStoredTokenData(provider);
+  if (!data) return null;
+  if (data.expiresAt && isTokenExpired(data)) {
+    return null;
+  }
+  return data.accessToken;
 }
-function clearVerifier() {
-  if (typeof window === "undefined") return;
-  sessionStorage.removeItem(VERIFIER_STORAGE_KEY);
+function getRefreshToken(provider) {
+  const data = getStoredTokenData(provider);
+  return data?.refreshToken ?? null;
+}
+function tokenResponseToStoredData(accessToken, expiresIn, refreshToken, scope) {
+  const data = {
+    accessToken,
+    refreshToken,
+    scope
+  };
+  if (expiresIn) {
+    data.expiresAt = Date.now() + expiresIn * 1e3;
+  }
+  return data;
 }
+
+// src/lib/backup/dropbox/auth.ts
+var PROVIDER = "dropbox";
+var STATE_STORAGE_KEY = "dropbox_oauth_state";
+var DROPBOX_AUTH_URL = "https://www.dropbox.com/oauth2/authorize";
 function getRedirectUri(callbackPath) {
   if (typeof window === "undefined") return "";
   return `${window.location.origin}${callbackPath}`;
 }
-async function handleDropboxCallback(appKey, callbackPath) {
+function generateState() {
+  const array = new Uint8Array(16);
+  crypto.getRandomValues(array);
+  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join(
+    ""
+  );
+}
+function storeOAuthState(state) {
+  if (typeof window === "undefined") return;
+  sessionStorage.setItem(STATE_STORAGE_KEY, state);
+}
+function getAndClearOAuthState() {
+  if (typeof window === "undefined") return null;
+  const state = sessionStorage.getItem(STATE_STORAGE_KEY);
+  sessionStorage.removeItem(STATE_STORAGE_KEY);
+  return state;
+}
+function isDropboxCallback() {
+  if (typeof window === "undefined") return false;
+  const url = new URL(window.location.href);
+  const code = url.searchParams.get("code");
+  const state = url.searchParams.get("state");
+  const storedState = sessionStorage.getItem(STATE_STORAGE_KEY);
+  return !!code && !!state && state === storedState;
+}
+async function handleDropboxCallback(callbackPath, apiClient) {
   if (typeof window === "undefined") return null;
   const url = new URL(window.location.href);
   const code = url.searchParams.get("code");
   const state = url.searchParams.get("state");
-  if (!code || state !== "dropbox_auth") return null;
-  const verifier = getStoredVerifier();
-  if (!verifier) return null;
+  const storedState = getAndClearOAuthState();
+  if (!code || !state || state !== storedState) {
+    return null;
+  }
   try {
-    const response = await fetch(DROPBOX_TOKEN_URL, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      },
-      body: new URLSearchParams({
+    const response = await postAuthOauthByProviderExchange({
+      client: apiClient,
+      path: { provider: PROVIDER },
+      body: {
         code,
-        grant_type: "authorization_code",
-        client_id: appKey,
-        redirect_uri: getRedirectUri(callbackPath),
-        code_verifier: verifier
-      })
+        redirect_uri: getRedirectUri(callbackPath)
+      }
     });
-    if (!response.ok) {
-      throw new Error("Token exchange failed");
+    if (!response.data?.access_token) {
+      throw new Error("No access token in response");
     }
-    const data = await response.json();
-    const token = data.access_token;
-    if (typeof token !== "string" || token.trim() === "") {
-      throw new Error("Invalid token response: access_token is missing or empty");
-    }
-    storeToken(token);
-    clearVerifier();
+    const tokenData = tokenResponseToStoredData(
+      response.data.access_token,
+      response.data.expires_in,
+      response.data.refresh_token,
+      response.data.scope
+    );
+    storeTokenData(PROVIDER, tokenData);
     window.history.replaceState({}, "", window.location.pathname);
-    return token;
+    return response.data.access_token;
+  } catch {
+    return null;
+  }
+}
+async function refreshDropboxToken(apiClient) {
+  const refreshToken = getRefreshToken(PROVIDER);
+  if (!refreshToken) return null;
+  try {
+    const response = await postAuthOauthByProviderRefresh({
+      client: apiClient,
+      path: { provider: PROVIDER },
+      body: { refresh_token: refreshToken }
+    });
+    if (!response.data?.access_token) {
+      throw new Error("No access token in refresh response");
+    }
+    const currentData = getStoredTokenData(PROVIDER);
+    const tokenData = tokenResponseToStoredData(
+      response.data.access_token,
+      response.data.expires_in,
+      response.data.refresh_token ?? currentData?.refreshToken,
+      response.data.scope ?? currentData?.scope
+    );
+    storeTokenData(PROVIDER, tokenData);
+    return response.data.access_token;
   } catch {
-    clearVerifier();
+    clearTokenData(PROVIDER);
     return null;
   }
 }
+async function revokeDropboxToken(apiClient) {
+  const tokenData = getStoredTokenData(PROVIDER);
+  if (!tokenData) return;
+  try {
+    const tokenToRevoke = tokenData.refreshToken ?? tokenData.accessToken;
+    await postAuthOauthByProviderRevoke({
+      client: apiClient,
+      path: { provider: PROVIDER },
+      body: { token: tokenToRevoke }
+    });
+  } catch {
+  } finally {
+    clearTokenData(PROVIDER);
+  }
+}
+async function getDropboxAccessToken(apiClient) {
+  const validToken = getValidAccessToken(PROVIDER);
+  if (validToken) return validToken;
+  return refreshDropboxToken(apiClient);
+}
 async function startDropboxAuth(appKey, callbackPath) {
-  const verifier = generateCodeVerifier();
-  const challenge = await generateCodeChallenge(verifier);
-  storeVerifier(verifier);
+  const state = generateState();
+  storeOAuthState(state);
   const params = new URLSearchParams({
     client_id: appKey,
     redirect_uri: getRedirectUri(callbackPath),
     response_type: "code",
-    code_challenge: challenge,
-    code_challenge_method: "S256",
-    state: "dropbox_auth",
+    state,
     token_access_type: "offline"
+    // Request refresh token
   });
   window.location.href = `${DROPBOX_AUTH_URL}?${params.toString()}`;
   return new Promise(() => {
   });
 }
-async function requestDropboxAccess(appKey, callbackPath) {
-  if (!appKey) {
-    throw new Error("Dropbox is not configured");
-  }
-  const storedToken = getStoredToken();
-  if (storedToken) {
-    return storedToken;
-  }
-  return startDropboxAuth(appKey, callbackPath);
+function clearToken() {
+  clearTokenData(PROVIDER);
+}
+function hasDropboxCredentials() {
+  const data = getStoredTokenData(PROVIDER);
+  return !!(data?.accessToken || data?.refreshToken);
 }
 
 // src/react/useDropboxAuth.ts
@@ -4662,26 +4772,41 @@ var DropboxAuthContext = createContext(null);
 function DropboxAuthProvider({
   appKey,
   callbackPath = "/auth/dropbox/callback",
+  apiClient,
   children
 }) {
   const [accessToken, setAccessToken] = useState10(null);
   const isConfigured = !!appKey;
   useEffect6(() => {
-    const storedToken = getStoredToken();
-    if (storedToken) {
-      setAccessToken(storedToken);
-    }
-  }, []);
+    const checkStoredToken = async () => {
+      if (hasDropboxCredentials()) {
+        const token = await getDropboxAccessToken(apiClient);
+        if (token) {
+          setAccessToken(token);
+        }
+      }
+    };
+    checkStoredToken();
+  }, [apiClient]);
   useEffect6(() => {
-    if (!isConfigured || !appKey) return;
+    if (!isConfigured) return;
     const handleCallback = async () => {
-      const token = await handleDropboxCallback(appKey, callbackPath);
-      if (token) {
-        setAccessToken(token);
+      if (isDropboxCallback()) {
+        const token = await handleDropboxCallback(callbackPath, apiClient);
+        if (token) {
+          setAccessToken(token);
+        }
       }
     };
     handleCallback();
-  }, [appKey, callbackPath, isConfigured]);
+  }, [callbackPath, isConfigured, apiClient]);
+  const refreshTokenFn = useCallback10(async () => {
+    const token = await getDropboxAccessToken(apiClient);
+    if (token) {
+      setAccessToken(token);
+    }
+    return token;
+  }, [apiClient]);
   const requestAccess = useCallback10(async () => {
     if (!isConfigured || !appKey) {
       throw new Error("Dropbox is not configured");
@@ -4689,17 +4814,17 @@ function DropboxAuthProvider({
     if (accessToken) {
       return accessToken;
     }
-    const storedToken = getStoredToken();
+    const storedToken = await getDropboxAccessToken(apiClient);
     if (storedToken) {
       setAccessToken(storedToken);
       return storedToken;
     }
-    return requestDropboxAccess(appKey, callbackPath);
-  }, [accessToken, appKey, callbackPath, isConfigured]);
-  const logout = useCallback10(() => {
-    clearToken();
+    return startDropboxAuth(appKey, callbackPath);
+  }, [accessToken, appKey, callbackPath, isConfigured, apiClient]);
+  const logout = useCallback10(async () => {
+    await revokeDropboxToken(apiClient);
     setAccessToken(null);
-  }, []);
+  }, [apiClient]);
   return createElement(
     DropboxAuthContext.Provider,
     {
@@ -4708,7 +4833,8 @@ function DropboxAuthProvider({
         isAuthenticated: !!accessToken,
         isConfigured,
         requestAccess,
-        logout
+        logout,
+        refreshToken: refreshTokenFn
       }
     },
     children
@@ -4735,25 +4861,25 @@ function useDropboxBackup(options) {
   const {
     accessToken: dropboxToken,
     isConfigured: isDropboxConfigured,
-    requestAccess: requestDropboxAccess2
+    requestAccess: requestDropboxAccess
   } = useDropboxAuth();
   const deps = useMemo4(
     () => ({
-      requestDropboxAccess: requestDropboxAccess2,
+      requestDropboxAccess,
       requestEncryptionKey: requestEncryptionKey2,
       exportConversation,
       importConversation
     }),
-    [requestDropboxAccess2, requestEncryptionKey2, exportConversation, importConversation]
+    [requestDropboxAccess, requestEncryptionKey2, exportConversation, importConversation]
   );
   const ensureToken = useCallback11(async () => {
     if (dropboxToken) return dropboxToken;
     try {
-      return await requestDropboxAccess2();
+      return await requestDropboxAccess();
     } catch {
       return null;
     }
-  }, [dropboxToken, requestDropboxAccess2]);
+  }, [dropboxToken, requestDropboxAccess]);
   const backup = useCallback11(
     async (backupOptions) => {
       if (!userAddress) {
@@ -4813,8 +4939,247 @@ function useDropboxBackup(options) {
   };
 }
 
+// src/react/useGoogleDriveAuth.ts
+import {
+  createContext as createContext2,
+  createElement as createElement2,
+  useCallback as useCallback12,
+  useContext as useContext2,
+  useEffect as useEffect7,
+  useState as useState11
+} from "react";
+
+// src/lib/backup/google/auth.ts
+var PROVIDER2 = "google-drive";
+var CODE_STORAGE_KEY = "google_oauth_state";
+var GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+var DRIVE_SCOPES = [
+  "https://www.googleapis.com/auth/drive.file"
+  // Access to files created by the app
+].join(" ");
+function getRedirectUri2(callbackPath) {
+  if (typeof window === "undefined") return "";
+  return `${window.location.origin}${callbackPath}`;
+}
+function generateState2() {
+  const array = new Uint8Array(16);
+  crypto.getRandomValues(array);
+  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join(
+    ""
+  );
+}
+function storeOAuthState2(state) {
+  if (typeof window === "undefined") return;
+  sessionStorage.setItem(CODE_STORAGE_KEY, state);
+}
+function getAndClearOAuthState2() {
+  if (typeof window === "undefined") return null;
+  const state = sessionStorage.getItem(CODE_STORAGE_KEY);
+  sessionStorage.removeItem(CODE_STORAGE_KEY);
+  return state;
+}
+function isGoogleDriveCallback() {
+  if (typeof window === "undefined") return false;
+  const url = new URL(window.location.href);
+  const code = url.searchParams.get("code");
+  const state = url.searchParams.get("state");
+  const storedState = sessionStorage.getItem(CODE_STORAGE_KEY);
+  return !!code && !!state && state === storedState;
+}
+async function handleGoogleDriveCallback(callbackPath, apiClient) {
+  if (typeof window === "undefined") return null;
+  const url = new URL(window.location.href);
+  const code = url.searchParams.get("code");
+  const state = url.searchParams.get("state");
+  const storedState = getAndClearOAuthState2();
+  if (!code || !state || state !== storedState) {
+    return null;
+  }
+  try {
+    const response = await postAuthOauthByProviderExchange({
+      client: apiClient,
+      path: { provider: PROVIDER2 },
+      body: {
+        code,
+        redirect_uri: getRedirectUri2(callbackPath)
+      }
+    });
+    if (!response.data?.access_token) {
+      throw new Error("No access token in response");
+    }
+    const tokenData = tokenResponseToStoredData(
+      response.data.access_token,
+      response.data.expires_in,
+      response.data.refresh_token,
+      response.data.scope
+    );
+    storeTokenData(PROVIDER2, tokenData);
+    window.history.replaceState({}, "", window.location.pathname);
+    return response.data.access_token;
+  } catch {
+    return null;
+  }
+}
+async function refreshGoogleDriveToken(apiClient) {
+  const refreshToken = getRefreshToken(PROVIDER2);
+  if (!refreshToken) return null;
+  try {
+    const response = await postAuthOauthByProviderRefresh({
+      client: apiClient,
+      path: { provider: PROVIDER2 },
+      body: { refresh_token: refreshToken }
+    });
+    if (!response.data?.access_token) {
+      throw new Error("No access token in refresh response");
+    }
+    const currentData = getStoredTokenData(PROVIDER2);
+    const tokenData = tokenResponseToStoredData(
+      response.data.access_token,
+      response.data.expires_in,
+      response.data.refresh_token ?? currentData?.refreshToken,
+      response.data.scope ?? currentData?.scope
+    );
+    storeTokenData(PROVIDER2, tokenData);
+    return response.data.access_token;
+  } catch {
+    clearTokenData(PROVIDER2);
+    return null;
+  }
+}
+async function revokeGoogleDriveToken(apiClient) {
+  const tokenData = getStoredTokenData(PROVIDER2);
+  if (!tokenData) return;
+  try {
+    const tokenToRevoke = tokenData.refreshToken ?? tokenData.accessToken;
+    await postAuthOauthByProviderRevoke({
+      client: apiClient,
+      path: { provider: PROVIDER2 },
+      body: { token: tokenToRevoke }
+    });
+  } catch {
+  } finally {
+    clearTokenData(PROVIDER2);
+  }
+}
+async function getGoogleDriveAccessToken(apiClient) {
+  const validToken = getValidAccessToken(PROVIDER2);
+  if (validToken) return validToken;
+  return refreshGoogleDriveToken(apiClient);
+}
+async function startGoogleDriveAuth(clientId, callbackPath) {
+  const state = generateState2();
+  storeOAuthState2(state);
+  const params = new URLSearchParams({
+    client_id: clientId,
+    redirect_uri: getRedirectUri2(callbackPath),
+    response_type: "code",
+    scope: DRIVE_SCOPES,
+    state,
+    access_type: "offline",
+    // Request refresh token
+    prompt: "consent"
+    // Force consent to always get refresh token
+  });
+  window.location.href = `${GOOGLE_AUTH_URL}?${params.toString()}`;
+  return new Promise(() => {
+  });
+}
+function getGoogleDriveStoredToken() {
+  return getValidAccessToken(PROVIDER2);
+}
+function clearGoogleDriveToken() {
+  clearTokenData(PROVIDER2);
+}
+function hasGoogleDriveCredentials() {
+  const data = getStoredTokenData(PROVIDER2);
+  return !!(data?.accessToken || data?.refreshToken);
+}
+
+// src/react/useGoogleDriveAuth.ts
+var GoogleDriveAuthContext = createContext2(null);
+function GoogleDriveAuthProvider({
+  clientId,
+  callbackPath = "/auth/google/callback",
+  apiClient,
+  children
+}) {
+  const [accessToken, setAccessToken] = useState11(null);
+  const isConfigured = !!clientId;
+  useEffect7(() => {
+    const checkStoredToken = async () => {
+      if (hasGoogleDriveCredentials()) {
+        const token = await getGoogleDriveAccessToken(apiClient);
+        if (token) {
+          setAccessToken(token);
+        }
+      }
+    };
+    checkStoredToken();
+  }, [apiClient]);
+  useEffect7(() => {
+    if (!isConfigured) return;
+    const handleCallback = async () => {
+      if (isGoogleDriveCallback()) {
+        const token = await handleGoogleDriveCallback(callbackPath, apiClient);
+        if (token) {
+          setAccessToken(token);
+        }
+      }
+    };
+    handleCallback();
+  }, [callbackPath, isConfigured, apiClient]);
+  const refreshTokenFn = useCallback12(async () => {
+    const token = await getGoogleDriveAccessToken(apiClient);
+    if (token) {
+      setAccessToken(token);
+    }
+    return token;
+  }, [apiClient]);
+  const requestAccess = useCallback12(async () => {
+    if (!isConfigured || !clientId) {
+      throw new Error("Google Drive is not configured");
+    }
+    if (accessToken) {
+      return accessToken;
+    }
+    const storedToken = await getGoogleDriveAccessToken(apiClient);
+    if (storedToken) {
+      setAccessToken(storedToken);
+      return storedToken;
+    }
+    return startGoogleDriveAuth(clientId, callbackPath);
+  }, [accessToken, clientId, callbackPath, isConfigured, apiClient]);
+  const logout = useCallback12(async () => {
+    await revokeGoogleDriveToken(apiClient);
+    setAccessToken(null);
+  }, [apiClient]);
+  return createElement2(
+    GoogleDriveAuthContext.Provider,
+    {
+      value: {
+        accessToken,
+        isAuthenticated: !!accessToken,
+        isConfigured,
+        requestAccess,
+        logout,
+        refreshToken: refreshTokenFn
+      }
+    },
+    children
+  );
+}
+function useGoogleDriveAuth() {
+  const context = useContext2(GoogleDriveAuthContext);
+  if (!context) {
+    throw new Error(
+      "useGoogleDriveAuth must be used within GoogleDriveAuthProvider"
+    );
+  }
+  return context;
+}
+
 // src/react/useGoogleDriveBackup.ts
-import { useCallback as useCallback12, useMemo as useMemo5 } from "react";
+import { useCallback as useCallback13, useMemo as useMemo5 } from "react";
 
 // src/lib/backup/google/api.ts
 var DRIVE_API_URL = "https://www.googleapis.com/drive/v3";
@@ -5121,14 +5486,17 @@ function useGoogleDriveBackup(options) {
   const {
     database,
     userAddress,
-    accessToken,
-    requestDriveAccess,
     requestEncryptionKey: requestEncryptionKey2,
     exportConversation,
     importConversation,
     rootFolder = DEFAULT_ROOT_FOLDER,
     conversationsFolder = DEFAULT_CONVERSATIONS_FOLDER
   } = options;
+  const {
+    accessToken: driveToken,
+    isConfigured: isDriveConfigured,
+    requestAccess: requestDriveAccess
+  } = useGoogleDriveAuth();
   const deps = useMemo5(
     () => ({
       requestDriveAccess,
@@ -5136,22 +5504,17 @@ function useGoogleDriveBackup(options) {
       exportConversation,
       importConversation
     }),
-    [
-      requestDriveAccess,
-      requestEncryptionKey2,
-      exportConversation,
-      importConversation
-    ]
+    [requestDriveAccess, requestEncryptionKey2, exportConversation, importConversation]
   );
-  const ensureToken = useCallback12(async () => {
-    if (accessToken) return accessToken;
+  const ensureToken = useCallback13(async () => {
+    if (driveToken) return driveToken;
     try {
       return await requestDriveAccess();
     } catch {
       return null;
     }
-  }, [accessToken, requestDriveAccess]);
-  const backup = useCallback12(
+  }, [driveToken, requestDriveAccess]);
+  const backup = useCallback13(
     async (backupOptions) => {
       if (!userAddress) {
         return { error: "Please sign in to backup to Google Drive" };
@@ -5178,7 +5541,7 @@ function useGoogleDriveBackup(options) {
     },
     [database, userAddress, ensureToken, deps, rootFolder, conversationsFolder]
   );
-  const restore = useCallback12(
+  const restore = useCallback13(
     async (restoreOptions) => {
       if (!userAddress) {
         return { error: "Please sign in to restore from Google Drive" };
@@ -5207,22 +5570,1130 @@ function useGoogleDriveBackup(options) {
   return {
     backup,
     restore,
-    isAuthenticated: !!accessToken
+    isConfigured: isDriveConfigured,
+    isAuthenticated: !!driveToken
+  };
+}
+
+// src/react/useICloudAuth.ts
+import {
+  createContext as createContext3,
+  createElement as createElement3,
+  useCallback as useCallback14,
+  useContext as useContext3,
+  useEffect as useEffect8,
+  useState as useState12
+} from "react";
+
+// src/lib/backup/icloud/api.ts
+var CLOUDKIT_JS_URL = "https://cdn.apple-cloudkit.com/ck/2/cloudkit.js";
+var DEFAULT_BACKUP_FOLDER2 = "conversations";
+var DEFAULT_CONTAINER_ID = "iCloud.Memoryless";
+var RECORD_TYPE = "ConversationBackup";
+var cloudKitLoadPromise = null;
+function isCloudKitAvailable() {
+  return typeof window !== "undefined" && !!window.CloudKit;
+}
+async function loadCloudKit() {
+  if (typeof window === "undefined") {
+    throw new Error("CloudKit JS can only be loaded in browser environment");
+  }
+  if (window.CloudKit) {
+    return;
+  }
+  if (cloudKitLoadPromise) {
+    return cloudKitLoadPromise;
+  }
+  cloudKitLoadPromise = new Promise((resolve, reject) => {
+    const script = document.createElement("script");
+    script.src = CLOUDKIT_JS_URL;
+    script.async = true;
+    script.onload = () => {
+      if (window.CloudKit) {
+        resolve();
+      } else {
+        reject(new Error("CloudKit JS loaded but CloudKit object not found"));
+      }
+    };
+    script.onerror = () => {
+      cloudKitLoadPromise = null;
+      reject(new Error("Failed to load CloudKit JS"));
+    };
+    document.head.appendChild(script);
+  });
+  return cloudKitLoadPromise;
+}
+async function ensureCloudKitLoaded() {
+  if (!isCloudKitAvailable()) {
+    await loadCloudKit();
+  }
+}
+async function configureCloudKit(config) {
+  await ensureCloudKitLoaded();
+  ensureAuthElements();
+  window.CloudKit.configure({
+    containers: [
+      {
+        containerIdentifier: config.containerIdentifier,
+        apiTokenAuth: {
+          apiToken: config.apiToken,
+          persist: true,
+          signInButton: {
+            id: "apple-sign-in-button",
+            theme: "black"
+          },
+          signOutButton: {
+            id: "apple-sign-out-button",
+            theme: "black"
+          }
+        },
+        environment: config.environment
+      }
+    ]
+  });
+}
+async function getContainer() {
+  await ensureCloudKitLoaded();
+  return window.CloudKit.getDefaultContainer();
+}
+function ensureAuthElements() {
+  let signInButton = document.getElementById("apple-sign-in-button");
+  let signOutButton = document.getElementById("apple-sign-out-button");
+  if (!signInButton) {
+    signInButton = document.createElement("div");
+    signInButton.id = "apple-sign-in-button";
+    signInButton.style.position = "fixed";
+    signInButton.style.top = "-9999px";
+    signInButton.style.left = "-9999px";
+    document.body.appendChild(signInButton);
+  }
+  if (!signOutButton) {
+    signOutButton = document.createElement("div");
+    signOutButton.id = "apple-sign-out-button";
+    signOutButton.style.position = "fixed";
+    signOutButton.style.top = "-9999px";
+    signOutButton.style.left = "-9999px";
+    document.body.appendChild(signOutButton);
+  }
+  return { signIn: signInButton, signOut: signOutButton };
+}
+async function authenticateICloud() {
+  const container = await getContainer();
+  ensureAuthElements();
+  return container.setUpAuth();
+}
+async function requestICloudSignIn() {
+  const container = await getContainer();
+  const { signIn } = ensureAuthElements();
+  const existingUser = await container.setUpAuth();
+  if (existingUser) {
+    return existingUser;
+  }
+  console.log("[CloudKit] Sign-in container innerHTML:", signIn.innerHTML);
+  console.log("[CloudKit] Sign-in container children:", signIn.children.length);
+  const appleButton = signIn.querySelector("a, button, [role='button'], div[id*='apple']");
+  console.log("[CloudKit] Found button element:", appleButton);
+  if (appleButton) {
+    console.log("[CloudKit] Clicking button...");
+    appleButton.click();
+  } else {
+    const anyClickable = signIn.firstElementChild;
+    if (anyClickable) {
+      console.log("[CloudKit] Clicking first child element:", anyClickable);
+      anyClickable.click();
+    }
+  }
+  return container.whenUserSignsIn();
+}
+async function uploadFileToICloud(filename, content) {
+  const container = await getContainer();
+  const database = container.privateCloudDatabase;
+  const recordName = `backup_${filename.replace(/[^a-zA-Z0-9]/g, "_")}`;
+  const arrayBuffer = await content.arrayBuffer();
+  const base64Data = btoa(
+    String.fromCharCode(...new Uint8Array(arrayBuffer))
+  );
+  const record = {
+    recordType: RECORD_TYPE,
+    recordName,
+    fields: {
+      filename: { value: filename },
+      data: { value: base64Data },
+      size: { value: content.size },
+      contentType: { value: content.type || "application/json" }
+    }
+  };
+  const response = await database.saveRecords(record);
+  if (!response.records || response.records.length === 0) {
+    throw new Error("Failed to upload file to iCloud");
+  }
+  const savedRecord = response.records[0];
+  return {
+    recordName: savedRecord.recordName,
+    filename,
+    modifiedAt: new Date(savedRecord.modified?.timestamp ?? Date.now()),
+    size: content.size
+  };
+}
+async function listICloudFiles() {
+  const container = await getContainer();
+  const database = container.privateCloudDatabase;
+  const query = {
+    recordType: RECORD_TYPE
+    // Note: Sorting requires SORTABLE index on the field in CloudKit Dashboard
+    // For now, we skip sorting and sort client-side after fetching
+  };
+  const allRecords = [];
+  let response = await database.performQuery(query);
+  if (response.records) {
+    allRecords.push(...response.records);
+  }
+  while (response.continuationMarker) {
+    break;
+  }
+  const files = allRecords.map((record) => ({
+    recordName: record.recordName,
+    filename: record.fields.filename?.value ?? "",
+    modifiedAt: new Date(record.modified?.timestamp ?? Date.now()),
+    size: typeof record.fields.data?.value === "object" && record.fields.data?.value !== null ? record.fields.data.value.size : 0
+  }));
+  return files.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
+}
+async function downloadICloudFile(recordName) {
+  const container = await getContainer();
+  const database = container.privateCloudDatabase;
+  const response = await database.fetchRecords([{ recordName }], {
+    desiredKeys: ["filename", "data", "contentType"]
+  });
+  if (!response.records || response.records.length === 0) {
+    throw new Error(`File not found: ${recordName}`);
+  }
+  const record = response.records[0];
+  const dataField = record.fields.data?.value;
+  if (!dataField) {
+    throw new Error("No data in record");
+  }
+  if (typeof dataField === "string") {
+    const binaryString = atob(dataField);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return new Blob([bytes], { type: "application/json" });
+  }
+  if (typeof dataField === "object" && "downloadURL" in dataField) {
+    const fetchResponse = await fetch(
+      dataField.downloadURL
+    );
+    if (!fetchResponse.ok) {
+      throw new Error(`Failed to download from iCloud: ${fetchResponse.status}`);
+    }
+    return fetchResponse.blob();
+  }
+  throw new Error("Unknown data format in iCloud record");
+}
+async function findICloudFile(filename) {
+  const container = await getContainer();
+  const database = container.privateCloudDatabase;
+  const query = {
+    recordType: RECORD_TYPE,
+    filterBy: [
+      {
+        fieldName: "filename",
+        comparator: "EQUALS",
+        fieldValue: { value: filename }
+      }
+    ]
+  };
+  const response = await database.performQuery(query);
+  if (!response.records || response.records.length === 0) {
+    return null;
+  }
+  const record = response.records[0];
+  return {
+    recordName: record.recordName,
+    filename: record.fields.filename?.value ?? "",
+    modifiedAt: new Date(record.modified?.timestamp ?? Date.now()),
+    size: typeof record.fields.data?.value === "object" && record.fields.data?.value !== null ? record.fields.data.value.size : 0
+  };
+}
+
+// src/react/useICloudAuth.ts
+var ICloudAuthContext = createContext3(null);
+function ICloudAuthProvider({
+  apiToken,
+  containerIdentifier = DEFAULT_CONTAINER_ID,
+  environment = "production",
+  children
+}) {
+  const [isAuthenticated, setIsAuthenticated] = useState12(false);
+  const [userRecordName, setUserRecordName] = useState12(null);
+  const [isAvailable, setIsAvailable] = useState12(false);
+  const [isConfigured, setIsConfigured] = useState12(false);
+  const [isLoading, setIsLoading] = useState12(false);
+  useEffect8(() => {
+    if (!apiToken || typeof window === "undefined") {
+      return;
+    }
+    const initCloudKit = async () => {
+      setIsLoading(true);
+      try {
+        await loadCloudKit();
+        setIsAvailable(true);
+        const config = {
+          containerIdentifier,
+          apiToken,
+          environment
+        };
+        await configureCloudKit(config);
+        setIsConfigured(true);
+        try {
+          const userIdentity = await authenticateICloud();
+          if (userIdentity) {
+            setIsAuthenticated(true);
+            setUserRecordName(userIdentity.userRecordName);
+          }
+        } catch {
+        }
+      } catch {
+        setIsAvailable(false);
+        setIsConfigured(false);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    initCloudKit();
+  }, [apiToken, containerIdentifier, environment]);
+  const requestAccess = useCallback14(async () => {
+    if (!isConfigured) {
+      throw new Error("iCloud is not configured");
+    }
+    if (isAuthenticated) {
+      return;
+    }
+    try {
+      const userIdentity = await requestICloudSignIn();
+      setIsAuthenticated(true);
+      setUserRecordName(userIdentity.userRecordName);
+    } catch (err) {
+      throw new Error(
+        err instanceof Error ? err.message : "Failed to sign in to iCloud"
+      );
+    }
+  }, [isAuthenticated, isConfigured]);
+  const logout = useCallback14(() => {
+    setIsAuthenticated(false);
+    setUserRecordName(null);
+  }, []);
+  return createElement3(
+    ICloudAuthContext.Provider,
+    {
+      value: {
+        isAuthenticated,
+        isConfigured,
+        isAvailable,
+        userRecordName,
+        requestAccess,
+        logout
+      }
+    },
+    children
+  );
+}
+function useICloudAuth() {
+  const context = useContext3(ICloudAuthContext);
+  if (!context) {
+    throw new Error("useICloudAuth must be used within ICloudAuthProvider");
+  }
+  return context;
+}
+function hasICloudCredentials() {
+  return isCloudKitAvailable();
+}
+function clearICloudAuth() {
+}
+
+// src/react/useICloudBackup.ts
+import { useCallback as useCallback15, useMemo as useMemo6 } from "react";
+
+// src/lib/backup/icloud/backup.ts
+var isAuthError3 = (err) => err instanceof Error && (err.message.includes("AUTHENTICATION") || err.message.includes("NOT_AUTHENTICATED") || err.message.includes("sign in"));
+async function pushConversationToICloud(database, conversationId, userAddress, deps, _retried = false) {
+  try {
+    await deps.requestEncryptionKey(userAddress);
+    const filename = `${conversationId}.json`;
+    const existingFile = await findICloudFile(filename);
+    if (existingFile) {
+      const { Q: Q4 } = await import("@nozbe/watermelondb");
+      const conversationsCollection = database.get("conversations");
+      const records = await conversationsCollection.query(Q4.where("conversation_id", conversationId)).fetch();
+      if (records.length > 0) {
+        const conversation = conversationToStored(records[0]);
+        const localUpdated = conversation.updatedAt.getTime();
+        const remoteModified = existingFile.modifiedAt.getTime();
+        if (localUpdated <= remoteModified) {
+          return "skipped";
+        }
+      }
+    }
+    const exportResult = await deps.exportConversation(
+      conversationId,
+      userAddress
+    );
+    if (!exportResult.success || !exportResult.blob) {
+      return "failed";
+    }
+    await uploadFileToICloud(filename, exportResult.blob);
+    return "uploaded";
+  } catch (err) {
+    if (isAuthError3(err) && !_retried) {
+      try {
+        await deps.requestICloudAccess();
+        return pushConversationToICloud(
+          database,
+          conversationId,
+          userAddress,
+          deps,
+          true
+        );
+      } catch {
+        return "failed";
+      }
+    }
+    return "failed";
+  }
+}
+async function performICloudExport(database, userAddress, deps, onProgress) {
+  await deps.requestEncryptionKey(userAddress);
+  const { Q: Q4 } = await import("@nozbe/watermelondb");
+  const conversationsCollection = database.get("conversations");
+  const records = await conversationsCollection.query(Q4.where("is_deleted", false)).fetch();
+  const conversations = records.map(conversationToStored);
+  const total = conversations.length;
+  if (total === 0) {
+    return { success: true, uploaded: 0, skipped: 0, total: 0 };
+  }
+  let uploaded = 0;
+  let skipped = 0;
+  for (let i = 0; i < conversations.length; i++) {
+    const conv = conversations[i];
+    onProgress?.(i + 1, total);
+    const result = await pushConversationToICloud(
+      database,
+      conv.conversationId,
+      userAddress,
+      deps
+    );
+    if (result === "uploaded") uploaded++;
+    if (result === "skipped") skipped++;
+  }
+  return { success: true, uploaded, skipped, total };
+}
+async function performICloudImport(userAddress, deps, onProgress) {
+  await deps.requestEncryptionKey(userAddress);
+  const remoteFiles = await listICloudFiles();
+  if (remoteFiles.length === 0) {
+    return {
+      success: false,
+      restored: 0,
+      failed: 0,
+      total: 0,
+      noBackupsFound: true
+    };
+  }
+  const jsonFiles = remoteFiles.filter(
+    (file) => file.filename.endsWith(".json")
+  );
+  const total = jsonFiles.length;
+  let restored = 0;
+  let failed = 0;
+  for (let i = 0; i < jsonFiles.length; i++) {
+    const file = jsonFiles[i];
+    onProgress?.(i + 1, total);
+    try {
+      const blob = await downloadICloudFile(file.recordName);
+      const result = await deps.importConversation(blob, userAddress);
+      if (result.success) {
+        restored++;
+      } else {
+        failed++;
+      }
+    } catch (err) {
+      if (isAuthError3(err)) {
+        try {
+          await deps.requestICloudAccess();
+          const blob = await downloadICloudFile(file.recordName);
+          const result = await deps.importConversation(blob, userAddress);
+          if (result.success) {
+            restored++;
+          } else {
+            failed++;
+          }
+        } catch {
+          failed++;
+        }
+      } else {
+        failed++;
+      }
+    }
+  }
+  return { success: true, restored, failed, total };
+}
+
+// src/react/useICloudBackup.ts
+function useICloudBackup(options) {
+  const {
+    database,
+    userAddress,
+    requestEncryptionKey: requestEncryptionKey2,
+    exportConversation,
+    importConversation
+  } = options;
+  const {
+    isAuthenticated,
+    isConfigured,
+    isAvailable,
+    requestAccess
+  } = useICloudAuth();
+  const deps = useMemo6(
+    () => ({
+      requestICloudAccess: requestAccess,
+      requestEncryptionKey: requestEncryptionKey2,
+      exportConversation,
+      importConversation
+    }),
+    [requestAccess, requestEncryptionKey2, exportConversation, importConversation]
+  );
+  const ensureAuthenticated = useCallback15(async () => {
+    if (isAuthenticated) return true;
+    try {
+      await requestAccess();
+      return true;
+    } catch {
+      return false;
+    }
+  }, [isAuthenticated, requestAccess]);
+  const backup = useCallback15(
+    async (backupOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to backup to iCloud" };
+      }
+      if (!isAvailable) {
+        return { error: "CloudKit JS is not loaded" };
+      }
+      if (!isConfigured) {
+        return { error: "iCloud is not configured" };
+      }
+      const authenticated = await ensureAuthenticated();
+      if (!authenticated) {
+        return { error: "iCloud access denied" };
+      }
+      try {
+        return await performICloudExport(
+          database,
+          userAddress,
+          deps,
+          backupOptions?.onProgress
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to backup to iCloud"
+        };
+      }
+    },
+    [database, userAddress, isAvailable, isConfigured, ensureAuthenticated, deps]
+  );
+  const restore = useCallback15(
+    async (restoreOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to restore from iCloud" };
+      }
+      if (!isAvailable) {
+        return { error: "CloudKit JS is not loaded" };
+      }
+      if (!isConfigured) {
+        return { error: "iCloud is not configured" };
+      }
+      const authenticated = await ensureAuthenticated();
+      if (!authenticated) {
+        return { error: "iCloud access denied" };
+      }
+      try {
+        return await performICloudImport(
+          userAddress,
+          deps,
+          restoreOptions?.onProgress
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to restore from iCloud"
+        };
+      }
+    },
+    [userAddress, isAvailable, isConfigured, ensureAuthenticated, deps]
+  );
+  return {
+    backup,
+    restore,
+    isConfigured,
+    isAuthenticated,
+    isAvailable
+  };
+}
+
+// src/react/useBackupAuth.ts
+import {
+  createContext as createContext4,
+  createElement as createElement4,
+  useCallback as useCallback16,
+  useContext as useContext4,
+  useEffect as useEffect9,
+  useState as useState13
+} from "react";
+var BackupAuthContext = createContext4(null);
+function BackupAuthProvider({
+  dropboxAppKey,
+  dropboxCallbackPath = "/auth/dropbox/callback",
+  googleClientId,
+  googleCallbackPath = "/auth/google/callback",
+  icloudApiToken,
+  icloudContainerIdentifier = DEFAULT_CONTAINER_ID,
+  icloudEnvironment = "production",
+  apiClient,
+  children
+}) {
+  const [dropboxToken, setDropboxToken] = useState13(null);
+  const isDropboxConfigured = !!dropboxAppKey;
+  const [googleToken, setGoogleToken] = useState13(null);
+  const isGoogleConfigured = !!googleClientId;
+  const [icloudAuthenticated, setIcloudAuthenticated] = useState13(false);
+  const [icloudUserRecordName, setIcloudUserRecordName] = useState13(null);
+  const [isIcloudAvailable, setIsIcloudAvailable] = useState13(false);
+  const isIcloudConfigured = isIcloudAvailable && !!icloudApiToken;
+  useEffect9(() => {
+    const checkStoredTokens = async () => {
+      if (hasDropboxCredentials()) {
+        const token = await getDropboxAccessToken(apiClient);
+        if (token) {
+          setDropboxToken(token);
+        }
+      }
+      if (hasGoogleDriveCredentials()) {
+        const token = await getGoogleDriveAccessToken(apiClient);
+        if (token) {
+          setGoogleToken(token);
+        }
+      }
+    };
+    checkStoredTokens();
+  }, [apiClient]);
+  useEffect9(() => {
+    if (!icloudApiToken || typeof window === "undefined") {
+      return;
+    }
+    const initCloudKit = async () => {
+      try {
+        await loadCloudKit();
+        setIsIcloudAvailable(true);
+        const config = {
+          containerIdentifier: icloudContainerIdentifier,
+          apiToken: icloudApiToken,
+          environment: icloudEnvironment
+        };
+        await configureCloudKit(config);
+        try {
+          const userIdentity = await authenticateICloud();
+          if (userIdentity) {
+            setIcloudAuthenticated(true);
+            setIcloudUserRecordName(userIdentity.userRecordName);
+          }
+        } catch {
+        }
+      } catch {
+        setIsIcloudAvailable(false);
+      }
+    };
+    initCloudKit();
+  }, [icloudApiToken, icloudContainerIdentifier, icloudEnvironment]);
+  useEffect9(() => {
+    if (!isDropboxConfigured) return;
+    const handleCallback = async () => {
+      if (isDropboxCallback()) {
+        const token = await handleDropboxCallback(
+          dropboxCallbackPath,
+          apiClient
+        );
+        if (token) {
+          setDropboxToken(token);
+        }
+      }
+    };
+    handleCallback();
+  }, [dropboxCallbackPath, isDropboxConfigured, apiClient]);
+  useEffect9(() => {
+    if (!isGoogleConfigured) return;
+    const handleCallback = async () => {
+      if (isGoogleDriveCallback()) {
+        const token = await handleGoogleDriveCallback(
+          googleCallbackPath,
+          apiClient
+        );
+        if (token) {
+          setGoogleToken(token);
+        }
+      }
+    };
+    handleCallback();
+  }, [googleCallbackPath, isGoogleConfigured, apiClient]);
+  const refreshDropboxTokenFn = useCallback16(async () => {
+    const token = await getDropboxAccessToken(apiClient);
+    if (token) {
+      setDropboxToken(token);
+    }
+    return token;
+  }, [apiClient]);
+  const requestDropboxAccess = useCallback16(async () => {
+    if (!isDropboxConfigured || !dropboxAppKey) {
+      throw new Error("Dropbox is not configured");
+    }
+    if (dropboxToken) {
+      return dropboxToken;
+    }
+    const storedToken = await getDropboxAccessToken(apiClient);
+    if (storedToken) {
+      setDropboxToken(storedToken);
+      return storedToken;
+    }
+    return startDropboxAuth(dropboxAppKey, dropboxCallbackPath);
+  }, [
+    dropboxToken,
+    dropboxAppKey,
+    dropboxCallbackPath,
+    isDropboxConfigured,
+    apiClient
+  ]);
+  const logoutDropbox = useCallback16(async () => {
+    await revokeDropboxToken(apiClient);
+    setDropboxToken(null);
+  }, [apiClient]);
+  const refreshGoogleTokenFn = useCallback16(async () => {
+    const token = await getGoogleDriveAccessToken(apiClient);
+    if (token) {
+      setGoogleToken(token);
+    }
+    return token;
+  }, [apiClient]);
+  const requestGoogleAccess = useCallback16(async () => {
+    if (!isGoogleConfigured || !googleClientId) {
+      throw new Error("Google Drive is not configured");
+    }
+    if (googleToken) {
+      return googleToken;
+    }
+    const storedToken = await getGoogleDriveAccessToken(apiClient);
+    if (storedToken) {
+      setGoogleToken(storedToken);
+      return storedToken;
+    }
+    return startGoogleDriveAuth(googleClientId, googleCallbackPath);
+  }, [
+    googleToken,
+    googleClientId,
+    googleCallbackPath,
+    isGoogleConfigured,
+    apiClient
+  ]);
+  const logoutGoogle = useCallback16(async () => {
+    await revokeGoogleDriveToken(apiClient);
+    setGoogleToken(null);
+  }, [apiClient]);
+  const refreshIcloudTokenFn = useCallback16(async () => {
+    try {
+      const userIdentity = await authenticateICloud();
+      if (userIdentity) {
+        setIcloudAuthenticated(true);
+        setIcloudUserRecordName(userIdentity.userRecordName);
+        return userIdentity.userRecordName;
+      }
+    } catch {
+    }
+    return null;
+  }, []);
+  const requestIcloudAccess = useCallback16(async () => {
+    if (!isIcloudConfigured) {
+      throw new Error("iCloud is not configured");
+    }
+    if (icloudAuthenticated && icloudUserRecordName) {
+      return icloudUserRecordName;
+    }
+    try {
+      const userIdentity = await requestICloudSignIn();
+      setIcloudAuthenticated(true);
+      setIcloudUserRecordName(userIdentity.userRecordName);
+      return userIdentity.userRecordName;
+    } catch (err) {
+      throw new Error(
+        err instanceof Error ? err.message : "Failed to sign in to iCloud"
+      );
+    }
+  }, [icloudAuthenticated, icloudUserRecordName, isIcloudConfigured]);
+  const logoutIcloud = useCallback16(async () => {
+    setIcloudAuthenticated(false);
+    setIcloudUserRecordName(null);
+  }, []);
+  const logoutAll = useCallback16(async () => {
+    await Promise.all([
+      isDropboxConfigured ? logoutDropbox() : Promise.resolve(),
+      isGoogleConfigured ? logoutGoogle() : Promise.resolve(),
+      isIcloudConfigured ? logoutIcloud() : Promise.resolve()
+    ]);
+  }, [isDropboxConfigured, isGoogleConfigured, isIcloudConfigured, logoutDropbox, logoutGoogle, logoutIcloud]);
+  const dropboxState = {
+    accessToken: dropboxToken,
+    isAuthenticated: !!dropboxToken,
+    isConfigured: isDropboxConfigured,
+    requestAccess: requestDropboxAccess,
+    logout: logoutDropbox,
+    refreshToken: refreshDropboxTokenFn
+  };
+  const googleDriveState = {
+    accessToken: googleToken,
+    isAuthenticated: !!googleToken,
+    isConfigured: isGoogleConfigured,
+    requestAccess: requestGoogleAccess,
+    logout: logoutGoogle,
+    refreshToken: refreshGoogleTokenFn
+  };
+  const icloudState = {
+    accessToken: icloudUserRecordName,
+    // Use userRecordName as the "token" for iCloud
+    isAuthenticated: icloudAuthenticated,
+    isConfigured: isIcloudConfigured,
+    requestAccess: requestIcloudAccess,
+    logout: logoutIcloud,
+    refreshToken: refreshIcloudTokenFn
+  };
+  return createElement4(
+    BackupAuthContext.Provider,
+    {
+      value: {
+        dropbox: dropboxState,
+        googleDrive: googleDriveState,
+        icloud: icloudState,
+        hasAnyProvider: isDropboxConfigured || isGoogleConfigured || isIcloudConfigured,
+        hasAnyAuthentication: !!dropboxToken || !!googleToken || icloudAuthenticated,
+        logoutAll
+      }
+    },
+    children
+  );
+}
+function useBackupAuth() {
+  const context = useContext4(BackupAuthContext);
+  if (!context) {
+    throw new Error("useBackupAuth must be used within BackupAuthProvider");
+  }
+  return context;
+}
+
+// src/react/useBackup.ts
+import { useCallback as useCallback17, useMemo as useMemo7 } from "react";
+function useBackup(options) {
+  const {
+    database,
+    userAddress,
+    requestEncryptionKey: requestEncryptionKey2,
+    exportConversation,
+    importConversation,
+    dropboxFolder = DEFAULT_BACKUP_FOLDER,
+    googleRootFolder = DEFAULT_ROOT_FOLDER,
+    googleConversationsFolder = DEFAULT_CONVERSATIONS_FOLDER
+  } = options;
+  const {
+    dropbox: dropboxAuth,
+    googleDrive: googleDriveAuth,
+    icloud: icloudAuth,
+    hasAnyProvider,
+    hasAnyAuthentication,
+    logoutAll
+  } = useBackupAuth();
+  const dropboxDeps = useMemo7(
+    () => ({
+      requestDropboxAccess: dropboxAuth.requestAccess,
+      requestEncryptionKey: requestEncryptionKey2,
+      exportConversation,
+      importConversation
+    }),
+    [dropboxAuth.requestAccess, requestEncryptionKey2, exportConversation, importConversation]
+  );
+  const googleDriveDeps = useMemo7(
+    () => ({
+      requestDriveAccess: googleDriveAuth.requestAccess,
+      requestEncryptionKey: requestEncryptionKey2,
+      exportConversation,
+      importConversation
+    }),
+    [googleDriveAuth.requestAccess, requestEncryptionKey2, exportConversation, importConversation]
+  );
+  const icloudDeps = useMemo7(
+    () => ({
+      requestICloudAccess: async () => {
+        await icloudAuth.requestAccess();
+      },
+      requestEncryptionKey: requestEncryptionKey2,
+      exportConversation,
+      importConversation
+    }),
+    [icloudAuth.requestAccess, requestEncryptionKey2, exportConversation, importConversation]
+  );
+  const dropboxBackup = useCallback17(
+    async (backupOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to backup to Dropbox" };
+      }
+      let token = dropboxAuth.accessToken;
+      if (!token) {
+        try {
+          token = await dropboxAuth.requestAccess();
+        } catch {
+          return { error: "Dropbox access denied" };
+        }
+      }
+      try {
+        return await performDropboxExport(
+          database,
+          userAddress,
+          token,
+          dropboxDeps,
+          backupOptions?.onProgress,
+          dropboxFolder
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to backup to Dropbox"
+        };
+      }
+    },
+    [database, userAddress, dropboxAuth, dropboxDeps, dropboxFolder]
+  );
+  const dropboxRestore = useCallback17(
+    async (restoreOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to restore from Dropbox" };
+      }
+      let token = dropboxAuth.accessToken;
+      if (!token) {
+        try {
+          token = await dropboxAuth.requestAccess();
+        } catch {
+          return { error: "Dropbox access denied" };
+        }
+      }
+      try {
+        return await performDropboxImport(
+          userAddress,
+          token,
+          dropboxDeps,
+          restoreOptions?.onProgress,
+          dropboxFolder
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to restore from Dropbox"
+        };
+      }
+    },
+    [userAddress, dropboxAuth, dropboxDeps, dropboxFolder]
+  );
+  const googleDriveBackup = useCallback17(
+    async (backupOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to backup to Google Drive" };
+      }
+      let token = googleDriveAuth.accessToken;
+      if (!token) {
+        try {
+          token = await googleDriveAuth.requestAccess();
+        } catch {
+          return { error: "Google Drive access denied" };
+        }
+      }
+      try {
+        return await performGoogleDriveExport(
+          database,
+          userAddress,
+          token,
+          googleDriveDeps,
+          backupOptions?.onProgress,
+          googleRootFolder,
+          googleConversationsFolder
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to backup to Google Drive"
+        };
+      }
+    },
+    [
+      database,
+      userAddress,
+      googleDriveAuth,
+      googleDriveDeps,
+      googleRootFolder,
+      googleConversationsFolder
+    ]
+  );
+  const googleDriveRestore = useCallback17(
+    async (restoreOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to restore from Google Drive" };
+      }
+      let token = googleDriveAuth.accessToken;
+      if (!token) {
+        try {
+          token = await googleDriveAuth.requestAccess();
+        } catch {
+          return { error: "Google Drive access denied" };
+        }
+      }
+      try {
+        return await performGoogleDriveImport(
+          userAddress,
+          token,
+          googleDriveDeps,
+          restoreOptions?.onProgress,
+          googleRootFolder,
+          googleConversationsFolder
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to restore from Google Drive"
+        };
+      }
+    },
+    [
+      userAddress,
+      googleDriveAuth,
+      googleDriveDeps,
+      googleRootFolder,
+      googleConversationsFolder
+    ]
+  );
+  const dropboxState = {
+    isConfigured: dropboxAuth.isConfigured,
+    isAuthenticated: dropboxAuth.isAuthenticated,
+    backup: dropboxBackup,
+    restore: dropboxRestore,
+    connect: dropboxAuth.requestAccess,
+    disconnect: dropboxAuth.logout
+  };
+  const googleDriveState = {
+    isConfigured: googleDriveAuth.isConfigured,
+    isAuthenticated: googleDriveAuth.isAuthenticated,
+    backup: googleDriveBackup,
+    restore: googleDriveRestore,
+    connect: googleDriveAuth.requestAccess,
+    disconnect: googleDriveAuth.logout
+  };
+  const icloudBackup = useCallback17(
+    async (backupOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to backup to iCloud" };
+      }
+      if (!icloudAuth.isConfigured) {
+        return { error: "iCloud is not configured" };
+      }
+      if (!icloudAuth.isAuthenticated) {
+        try {
+          await icloudAuth.requestAccess();
+        } catch {
+          return { error: "iCloud access denied" };
+        }
+      }
+      try {
+        return await performICloudExport(
+          database,
+          userAddress,
+          icloudDeps,
+          backupOptions?.onProgress
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to backup to iCloud"
+        };
+      }
+    },
+    [database, userAddress, icloudAuth, icloudDeps]
+  );
+  const icloudRestore = useCallback17(
+    async (restoreOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to restore from iCloud" };
+      }
+      if (!icloudAuth.isConfigured) {
+        return { error: "iCloud is not configured" };
+      }
+      if (!icloudAuth.isAuthenticated) {
+        try {
+          await icloudAuth.requestAccess();
+        } catch {
+          return { error: "iCloud access denied" };
+        }
+      }
+      try {
+        return await performICloudImport(
+          userAddress,
+          icloudDeps,
+          restoreOptions?.onProgress
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to restore from iCloud"
+        };
+      }
+    },
+    [userAddress, icloudAuth, icloudDeps]
+  );
+  const icloudState = {
+    isConfigured: icloudAuth.isConfigured,
+    isAuthenticated: icloudAuth.isAuthenticated,
+    backup: icloudBackup,
+    restore: icloudRestore,
+    connect: icloudAuth.requestAccess,
+    disconnect: icloudAuth.logout
+  };
+  return {
+    dropbox: dropboxState,
+    googleDrive: googleDriveState,
+    icloud: icloudState,
+    hasAnyProvider,
+    hasAnyAuthentication,
+    disconnectAll: logoutAll
   };
 }
 export {
+  DEFAULT_CONVERSATIONS_FOLDER as BACKUP_DRIVE_CONVERSATIONS_FOLDER,
+  DEFAULT_ROOT_FOLDER as BACKUP_DRIVE_ROOT_FOLDER,
+  DEFAULT_BACKUP_FOLDER2 as BACKUP_ICLOUD_FOLDER,
+  BackupAuthProvider,
   Conversation as ChatConversation,
   Message as ChatMessage,
   DEFAULT_BACKUP_FOLDER,
   DEFAULT_CONVERSATIONS_FOLDER as DEFAULT_DRIVE_CONVERSATIONS_FOLDER,
   DEFAULT_ROOT_FOLDER as DEFAULT_DRIVE_ROOT_FOLDER,
+  DEFAULT_BACKUP_FOLDER as DEFAULT_DROPBOX_FOLDER,
+  DEFAULT_BACKUP_FOLDER2 as DEFAULT_ICLOUD_BACKUP_FOLDER,
   DEFAULT_TOOL_SELECTOR_MODEL,
   DropboxAuthProvider,
+  GoogleDriveAuthProvider,
+  ICloudAuthProvider,
   Memory as StoredMemoryModel,
   ModelPreference as StoredModelPreferenceModel,
   chatStorageMigrations,
   chatStorageSchema,
   clearToken as clearDropboxToken,
+  clearGoogleDriveToken,
+  clearICloudAuth,
   createMemoryContextSystemMessage,
   decryptData,
   decryptDataBytes,
@@ -5233,8 +6704,11 @@ export {
   generateCompositeKey,
   generateConversationId,
   generateUniqueKey,
-  getStoredToken as getDropboxToken,
+  getGoogleDriveStoredToken,
+  hasDropboxCredentials,
   hasEncryptionKey,
+  hasGoogleDriveCredentials,
+  hasICloudCredentials,
   memoryStorageSchema,
   requestEncryptionKey,
   sdkMigrations,
@@ -5242,13 +6716,17 @@ export {
   sdkSchema,
   selectTool,
   settingsStorageSchema,
-  storeToken as storeDropboxToken,
+  useBackup,
+  useBackupAuth,
   useChat,
   useChatStorage,
   useDropboxAuth,
   useDropboxBackup,
   useEncryption,
+  useGoogleDriveAuth,
   useGoogleDriveBackup,
+  useICloudAuth,
+  useICloudBackup,
   useImageGeneration,
   useMemoryStorage,
   useModels,