@reverbia/sdk 1.0.0-next.20251229084841 → 1.1.0-next.20251230221037

package/dist/expo/index.cjs

@@ -2372,6 +2372,24 @@ async function getMemoriesByKeyOp(ctx, namespace, key) {
   return results.map(memoryToStored);
 }
 async function saveMemoryOp(ctx, opts) {
+  if (!opts.namespace || typeof opts.namespace !== "string") {
+    throw new Error("Namespace is required and must be a string");
+  }
+  if (!opts.key || typeof opts.key !== "string") {
+    throw new Error("Key is required and must be a string");
+  }
+  if (!opts.value || typeof opts.value !== "string") {
+    throw new Error("Value is required and must be a string");
+  }
+  if (!opts.type || typeof opts.type !== "string") {
+    throw new Error("Type is required and must be a string");
+  }
+  if (typeof opts.confidence !== "number" || opts.confidence < 0 || opts.confidence > 1) {
+    throw new Error("Confidence must be a number between 0 and 1");
+  }
+  if (typeof opts.pii !== "boolean") {
+    throw new Error("PII must be a boolean");
+  }
   const compositeKey = generateCompositeKey(opts.namespace, opts.key);
   const uniqueKey = generateUniqueKey(opts.namespace, opts.key, opts.value);
   const result = await ctx.database.write(async () => {

package/dist/expo/index.d.mts

@@ -647,6 +647,12 @@ interface BaseUseMemoryStorageOptions {
     onFactsExtracted?: (facts: MemoryExtractionResult) => void;
     getToken?: () => Promise<string | null>;
     baseUrl?: string;
+    /** Wallet address for encryption (optional - encryption disabled if not provided) */
+    walletAddress?: string | null;
+    /** Function to request encryption key (optional - encryption disabled if not provided) */
+    requestEncryptionKey?: (address: string) => Promise<void>;
+    /** Function to sign message for migration (optional - migration disabled if not provided) */
+    signMessage?: (message: string) => Promise<string>;
 }
 interface BaseUseMemoryStorageResult {
     memories: StoredMemory[];
@@ -781,6 +787,12 @@ interface BaseUseChatStorageOptions {
     onData?: (chunk: string) => void;
     onFinish?: (response: LlmapiResponseResponse) => void;
     onError?: (error: Error) => void;
+    /** Wallet address for encryption (optional - encryption disabled if not provided) */
+    walletAddress?: string | null;
+    /** Function to request encryption key (optional - encryption disabled if not provided) */
+    requestEncryptionKey?: (address: string) => Promise<void>;
+    /** Function to sign message for migration (optional - required for migrating old encrypted data) */
+    signMessage?: (message: string) => Promise<string>;
 }
 interface BaseSendMessageWithStorageArgs {
     content: string;

package/dist/expo/index.d.ts

@@ -647,6 +647,12 @@ interface BaseUseMemoryStorageOptions {
     onFactsExtracted?: (facts: MemoryExtractionResult) => void;
     getToken?: () => Promise<string | null>;
     baseUrl?: string;
+    /** Wallet address for encryption (optional - encryption disabled if not provided) */
+    walletAddress?: string | null;
+    /** Function to request encryption key (optional - encryption disabled if not provided) */
+    requestEncryptionKey?: (address: string) => Promise<void>;
+    /** Function to sign message for migration (optional - migration disabled if not provided) */
+    signMessage?: (message: string) => Promise<string>;
 }
 interface BaseUseMemoryStorageResult {
     memories: StoredMemory[];
@@ -781,6 +787,12 @@ interface BaseUseChatStorageOptions {
     onData?: (chunk: string) => void;
     onFinish?: (response: LlmapiResponseResponse) => void;
     onError?: (error: Error) => void;
+    /** Wallet address for encryption (optional - encryption disabled if not provided) */
+    walletAddress?: string | null;
+    /** Function to request encryption key (optional - encryption disabled if not provided) */
+    requestEncryptionKey?: (address: string) => Promise<void>;
+    /** Function to sign message for migration (optional - required for migrating old encrypted data) */
+    signMessage?: (message: string) => Promise<string>;
 }
 interface BaseSendMessageWithStorageArgs {
     content: string;

package/dist/expo/index.mjs

@@ -2336,6 +2336,24 @@ async function getMemoriesByKeyOp(ctx, namespace, key) {
   return results.map(memoryToStored);
 }
 async function saveMemoryOp(ctx, opts) {
+  if (!opts.namespace || typeof opts.namespace !== "string") {
+    throw new Error("Namespace is required and must be a string");
+  }
+  if (!opts.key || typeof opts.key !== "string") {
+    throw new Error("Key is required and must be a string");
+  }
+  if (!opts.value || typeof opts.value !== "string") {
+    throw new Error("Value is required and must be a string");
+  }
+  if (!opts.type || typeof opts.type !== "string") {
+    throw new Error("Type is required and must be a string");
+  }
+  if (typeof opts.confidence !== "number" || opts.confidence < 0 || opts.confidence > 1) {
+    throw new Error("Confidence must be a number between 0 and 1");
+  }
+  if (typeof opts.pii !== "boolean") {
+    throw new Error("PII must be a boolean");
+  }
   const compositeKey = generateCompositeKey(opts.namespace, opts.key);
   const uniqueKey = generateUniqueKey(opts.namespace, opts.key, opts.value);
   const result = await ctx.database.write(async () => {

package/dist/react/chunk-KUFGQF6E.mjs

@@ -0,0 +1,290 @@
+import {
+  decryptData,
+  encryptData,
+  hasEncryptionKey
+} from "./chunk-T56Y62G7.mjs";
+
+// src/lib/backup/oauth/storage.ts
+var STORAGE_KEY_PREFIX = "oauth_token_";
+var ENCRYPTION_PREFIX = "enc:";
+var SESSION_KEY_STORAGE_KEY = "oauth_session_encryption_key";
+function getStorageKey(provider) {
+  return `${STORAGE_KEY_PREFIX}${provider}`;
+}
+function isEncrypted(value) {
+  return value.startsWith(ENCRYPTION_PREFIX);
+}
+async function getOrCreateSessionKey() {
+  if (typeof window === "undefined") {
+    throw new Error("Session key generation requires browser environment");
+  }
+  let sessionKey = sessionStorage.getItem(SESSION_KEY_STORAGE_KEY);
+  if (sessionKey) {
+    return sessionKey;
+  }
+  const keyBytes = crypto.getRandomValues(new Uint8Array(32));
+  sessionKey = Array.from(keyBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  sessionStorage.setItem(SESSION_KEY_STORAGE_KEY, sessionKey);
+  return sessionKey;
+}
+async function encryptWithSessionKey(plaintext) {
+  const sessionKeyHex = await getOrCreateSessionKey();
+  const keyBytes = hexToBytes(sessionKeyHex);
+  const key = await crypto.subtle.importKey(
+    "raw",
+    keyBytes.buffer,
+    { name: "AES-GCM" },
+    false,
+    ["encrypt", "decrypt"]
+  );
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const plaintextBytes = new TextEncoder().encode(plaintext);
+  const encryptedData = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv },
+    key,
+    plaintextBytes.buffer
+  );
+  const encryptedBytes = new Uint8Array(encryptedData);
+  const combined = new Uint8Array(iv.length + encryptedBytes.length);
+  combined.set(iv, 0);
+  combined.set(encryptedBytes, iv.length);
+  return Array.from(combined).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function decryptWithSessionKey(encryptedHex) {
+  const sessionKeyHex = sessionStorage.getItem(SESSION_KEY_STORAGE_KEY);
+  if (!sessionKeyHex) {
+    throw new Error("Session key not found");
+  }
+  const keyBytes = hexToBytes(sessionKeyHex);
+  const key = await crypto.subtle.importKey(
+    "raw",
+    keyBytes.buffer,
+    { name: "AES-GCM" },
+    false,
+    ["encrypt", "decrypt"]
+  );
+  const combined = hexToBytes(encryptedHex);
+  const iv = combined.slice(0, 12);
+  const encryptedData = combined.slice(12);
+  const decryptedData = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv },
+    key,
+    encryptedData
+  );
+  return new TextDecoder().decode(decryptedData);
+}
+function hexToBytes(hex) {
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(cleanHex.length / 2);
+  for (let i = 0; i < cleanHex.length; i += 2) {
+    bytes[i / 2] = parseInt(cleanHex.slice(i, i + 2), 16);
+  }
+  return bytes;
+}
+async function reEncryptUnencryptedTokens(walletAddress) {
+  if (typeof window === "undefined") return;
+  if (!hasEncryptionKey(walletAddress)) return;
+  const providers = ["google-drive", "dropbox"];
+  for (const provider of providers) {
+    try {
+      const stored = localStorage.getItem(getStorageKey(provider));
+      if (!stored) continue;
+      if (!isEncrypted(stored)) {
+        try {
+          const data = JSON.parse(stored);
+          if (data.accessToken) {
+            await storeTokenData(provider, data, walletAddress);
+          }
+        } catch {
+          continue;
+        }
+      } else {
+        const encryptedPayload = stored.slice(ENCRYPTION_PREFIX.length);
+        try {
+          const decrypted = await decryptWithSessionKey(encryptedPayload);
+          const data = JSON.parse(decrypted);
+          if (data.accessToken) {
+            await storeTokenData(provider, data, walletAddress);
+          }
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+}
+async function getStoredTokenData(provider, walletAddress) {
+  if (typeof window === "undefined") return null;
+  try {
+    const stored = localStorage.getItem(getStorageKey(provider));
+    if (!stored) return null;
+    if (isEncrypted(stored)) {
+      const encryptedPayload = stored.slice(ENCRYPTION_PREFIX.length);
+      if (walletAddress && hasEncryptionKey(walletAddress)) {
+        try {
+          const decrypted = await decryptData(encryptedPayload, walletAddress);
+          const data = JSON.parse(decrypted);
+          if (!data.accessToken) return null;
+          return data;
+        } catch {
+        }
+      }
+      try {
+        const decrypted = await decryptWithSessionKey(encryptedPayload);
+        const data = JSON.parse(decrypted);
+        if (!data.accessToken) return null;
+        if (walletAddress && hasEncryptionKey(walletAddress)) {
+          try {
+            await storeTokenData(provider, data, walletAddress);
+          } catch {
+            console.error(`Failed to re-encrypt OAuth token for ${provider}`);
+          }
+        }
+        return data;
+      } catch {
+        return null;
+      }
+    } else {
+      try {
+        const data = JSON.parse(stored);
+        if (!data.accessToken) return null;
+        if (walletAddress && hasEncryptionKey(walletAddress)) {
+          try {
+            await storeTokenData(provider, data, walletAddress);
+          } catch {
+            console.error(`Failed to re-encrypt OAuth token for ${provider}`);
+          }
+        } else {
+          try {
+            await storeTokenData(provider, data);
+          } catch {
+            console.error(`Failed to encrypt OAuth token for ${provider}`);
+          }
+        }
+        return data;
+      } catch {
+        return null;
+      }
+    }
+  } catch {
+    return null;
+  }
+}
+function getStoredTokenDataSync(provider) {
+  if (typeof window === "undefined") return null;
+  try {
+    const stored = localStorage.getItem(getStorageKey(provider));
+    if (!stored) return null;
+    if (isEncrypted(stored)) {
+      return null;
+    }
+    const data = JSON.parse(stored);
+    if (!data.accessToken) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+async function storeTokenData(provider, data, walletAddress) {
+  if (typeof window === "undefined") return;
+  const jsonData = JSON.stringify(data);
+  if (walletAddress && hasEncryptionKey(walletAddress)) {
+    try {
+      const encrypted = await encryptData(jsonData, walletAddress);
+      localStorage.setItem(getStorageKey(provider), `${ENCRYPTION_PREFIX}${encrypted}`);
+      return;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown encryption error";
+      throw new Error(`OAuth token encryption failed: ${message}`);
+    }
+  }
+  try {
+    const encrypted = await encryptWithSessionKey(jsonData);
+    localStorage.setItem(getStorageKey(provider), `${ENCRYPTION_PREFIX}${encrypted}`);
+  } catch (error) {
+    const sessionStorageAvailable = typeof window !== "undefined" && typeof window.sessionStorage !== "undefined" && typeof window.sessionStorage.getItem === "function" && typeof window.sessionStorage.setItem === "function";
+    if (!sessionStorageAvailable) {
+      localStorage.setItem(getStorageKey(provider), jsonData);
+    } else {
+      const message = error instanceof Error ? error.message : "Unknown encryption error";
+      throw new Error(`OAuth token encryption failed: ${message}`);
+    }
+  }
+}
+function clearTokenData(provider) {
+  if (typeof window === "undefined") return;
+  localStorage.removeItem(getStorageKey(provider));
+}
+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;
+}
+async function getValidAccessToken(provider, walletAddress) {
+  const data = await getStoredTokenData(provider, walletAddress);
+  if (!data) return null;
+  if (data.expiresAt && isTokenExpired(data)) {
+    return null;
+  }
+  return data.accessToken;
+}
+function getValidAccessTokenSync(provider) {
+  const data = getStoredTokenDataSync(provider);
+  if (!data) return null;
+  if (data.expiresAt && isTokenExpired(data)) {
+    return null;
+  }
+  return data.accessToken;
+}
+async function getRefreshToken(provider, walletAddress) {
+  const data = await getStoredTokenData(provider, walletAddress);
+  return data?.refreshToken ?? null;
+}
+function getRefreshTokenSync(provider) {
+  const data = getStoredTokenDataSync(provider);
+  return data?.refreshToken ?? null;
+}
+function hasStoredCredentialsSync(provider) {
+  if (typeof window === "undefined") return false;
+  const stored = localStorage.getItem(getStorageKey(provider));
+  if (!stored) return false;
+  if (isEncrypted(stored)) {
+    return true;
+  }
+  try {
+    const data = JSON.parse(stored);
+    return !!(data?.accessToken || data?.refreshToken);
+  } catch {
+    return false;
+  }
+}
+function tokenResponseToStoredData(accessToken, expiresIn, refreshToken, scope) {
+  const data = {
+    accessToken,
+    refreshToken,
+    scope
+  };
+  if (expiresIn) {
+    data.expiresAt = Date.now() + expiresIn * 1e3;
+  }
+  return data;
+}
+
+export {
+  reEncryptUnencryptedTokens,
+  getStoredTokenData,
+  getStoredTokenDataSync,
+  storeTokenData,
+  clearTokenData,
+  isTokenExpired,
+  getValidAccessToken,
+  getValidAccessTokenSync,
+  getRefreshToken,
+  getRefreshTokenSync,
+  hasStoredCredentialsSync,
+  tokenResponseToStoredData
+};