@lumiapassport/core 1.0.0

package/dist/auth/index.js

@@ -0,0 +1,631 @@
+// src/auth/base64url.ts
+function arrayBufferToBase64url(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function base64urlToUint8Array(base64url) {
+  const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
+  const pad = base64.length % 4 ? 4 - base64.length % 4 : 0;
+  const padded = base64 + "=".repeat(pad);
+  const binary = atob(padded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function arrayBufferToBase64(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+
+// src/auth/storage.ts
+var MemoryStorage = class {
+  storage = /* @__PURE__ */ new Map();
+  getItem(key) {
+    return this.storage.get(key) || null;
+  }
+  setItem(key, value) {
+    this.storage.set(key, value);
+  }
+  removeItem(key) {
+    this.storage.delete(key);
+  }
+  /**
+   * Clear all items from memory storage
+   */
+  clear() {
+    this.storage.clear();
+  }
+  /**
+   * Get all keys in storage
+   */
+  keys() {
+    return Array.from(this.storage.keys());
+  }
+  /**
+   * Get number of items in storage
+   */
+  get size() {
+    return this.storage.size;
+  }
+};
+var LocalStorageAdapter = class {
+  fallback = null;
+  constructor() {
+    if (!this.isLocalStorageAvailable()) {
+      console.warn("[Storage] localStorage not available, falling back to memory storage");
+      this.fallback = new MemoryStorage();
+    }
+  }
+  isLocalStorageAvailable() {
+    try {
+      const win = typeof globalThis !== "undefined" && globalThis.window;
+      const storage = win ? win.localStorage : void 0;
+      if (!storage) {
+        return false;
+      }
+      const testKey = "__lumia_storage_test__";
+      storage.setItem(testKey, "test");
+      storage.removeItem(testKey);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getItem(key) {
+    console.log("[Storage] getItem called for key:", key);
+    if (this.fallback) {
+      console.log("[Storage] Using fallback memory storage");
+      return this.fallback.getItem(key);
+    }
+    try {
+      const win = typeof globalThis !== "undefined" && globalThis.window;
+      const value = win?.localStorage?.getItem(key) || null;
+      console.log("[Storage] Read from localStorage:", {
+        key,
+        hasValue: !!value,
+        valueLength: value?.length,
+        allKeys: win?.localStorage ? Object.keys(win.localStorage) : []
+      });
+      return value;
+    } catch (error) {
+      console.error("[Storage] Error reading from localStorage:", error);
+      return null;
+    }
+  }
+  setItem(key, value) {
+    console.log("[Storage] setItem called:", { key, valueLength: value.length });
+    if (this.fallback) {
+      console.log("[Storage] Using fallback memory storage for write");
+      this.fallback.setItem(key, value);
+      return;
+    }
+    try {
+      const win = typeof globalThis !== "undefined" && globalThis.window;
+      win?.localStorage?.setItem(key, value);
+      console.log("[Storage] Successfully wrote to localStorage");
+      const verification = win?.localStorage?.getItem(key);
+      if (!verification) {
+        console.error("[Storage] \u26A0\uFE0F VERIFICATION FAILED: Value not found after write!");
+      } else if (verification !== value) {
+        console.error("[Storage] \u26A0\uFE0F VERIFICATION FAILED: Value mismatch after write!");
+      } else {
+        console.log("[Storage] \u2705 Write verified successfully");
+      }
+    } catch (error) {
+      console.error("[Storage] Error writing to localStorage:", error);
+      if (!this.fallback) {
+        this.fallback = new MemoryStorage();
+        this.fallback.setItem(key, value);
+      }
+    }
+  }
+  removeItem(key) {
+    if (this.fallback) {
+      this.fallback.removeItem(key);
+      return;
+    }
+    try {
+      const win = typeof globalThis !== "undefined" && globalThis.window;
+      win?.localStorage?.removeItem(key);
+    } catch (error) {
+      console.error("[Storage] Error removing from localStorage:", error);
+    }
+  }
+};
+async function storageGet(storage, key) {
+  const result = storage.getItem(key);
+  return result instanceof Promise ? await result : result;
+}
+async function storageSet(storage, key, value) {
+  const result = storage.setItem(key, value);
+  if (result instanceof Promise) {
+    await result;
+  }
+}
+async function storageRemove(storage, key) {
+  const result = storage.removeItem(key);
+  if (result instanceof Promise) {
+    await result;
+  }
+}
+function getProjectId() {
+  if (typeof globalThis !== "undefined" && globalThis.window) {
+    return globalThis.window.__LUMIA_PROJECT_ID__;
+  }
+  return void 0;
+}
+function addProjectIdToUrl(url, projectId) {
+  try {
+    const pid = projectId || getProjectId();
+    if (pid) {
+      const separator = url.includes("?") ? "&" : "?";
+      return `${url}${separator}projectId=${encodeURIComponent(pid)}`;
+    }
+  } catch (error) {
+  }
+  return url;
+}
+
+// src/auth/jwt.ts
+var TOKEN_STORAGE_KEY = "lumia-jwt-tokens";
+var USER_ID_KEY = "lumia-current-user-id";
+var tssUrlProvider;
+function configureJwtModule(config) {
+  if (config.tssUrl) {
+    tssUrlProvider = () => config.tssUrl;
+  }
+}
+var BUILD_TSS_URL = "http://localhost:9256";
+function getTssUrl() {
+  if (tssUrlProvider) {
+    return tssUrlProvider();
+  }
+  if (typeof globalThis !== "undefined" && globalThis.window) {
+    const services = globalThis.window.__LUMIA_SERVICES__;
+    if (services?.tssUrl) {
+      return services.tssUrl;
+    }
+  }
+  {
+    return BUILD_TSS_URL;
+  }
+}
+var JwtTokenManager = class {
+  tokens = null;
+  storage;
+  refreshPromise = null;
+  // Mutex for refresh operations
+  constructor(storage) {
+    this.storage = storage || new LocalStorageAdapter();
+    console.log("[JWT] JwtTokenManager initializing...");
+    this.loadTokensFromStorage();
+  }
+  async loadTokensFromStorage() {
+    try {
+      const stored = await this.storage.getItem(TOKEN_STORAGE_KEY);
+      console.log("[JWT] Loading tokens from storage:", !!stored);
+      if (stored) {
+        this.tokens = JSON.parse(stored);
+        console.log("[JWT] Parsed tokens:", {
+          hasAccessToken: !!this.tokens?.accessToken,
+          hasRefreshToken: !!this.tokens?.refreshToken,
+          userId: this.tokens?.userId,
+          expiresAt: this.tokens?.expiresAt,
+          currentTime: Date.now(),
+          timeToExpiry: this.tokens?.expiresAt ? (this.tokens.expiresAt - Date.now()) / 1e3 : "N/A"
+        });
+        if (this.tokens && this.isTokenExpired()) {
+          console.log("[JWT] Access token is expired");
+          if (this.tokens.refreshToken) {
+            console.log("[JWT] Refresh token available, will attempt renewal when needed");
+          } else {
+            console.log("[JWT] No refresh token available, clearing tokens");
+            await this.clearTokens();
+          }
+        } else {
+          console.log("[JWT] Access token is valid, keeping tokens");
+        }
+      } else {
+        console.log("[JWT] No tokens found in storage");
+      }
+    } catch (error) {
+      console.error("[JWT] Error loading tokens from storage:", error);
+      await this.clearTokens();
+    }
+  }
+  async saveTokensToStorage() {
+    try {
+      if (this.tokens) {
+        const tokenString = JSON.stringify(this.tokens);
+        console.log("[JWT] Saving to storage with key:", TOKEN_STORAGE_KEY);
+        console.log("[JWT] Token data being saved:", {
+          hasAccessToken: !!this.tokens.accessToken,
+          hasRefreshToken: !!this.tokens.refreshToken,
+          userId: this.tokens.userId,
+          expiresAt: this.tokens.expiresAt,
+          tokenStringLength: tokenString.length
+        });
+        await this.storage.setItem(TOKEN_STORAGE_KEY, tokenString);
+        await this.storage.setItem(USER_ID_KEY, this.tokens.userId);
+        console.log("[JWT] Tokens saved to storage");
+      } else {
+        console.warn("[JWT] No tokens to save");
+      }
+    } catch (error) {
+      console.error("[JWT] Failed to save tokens to storage:", error);
+    }
+  }
+  async setTokens(response) {
+    console.log("[JWT] \u2705 setTokens() called - Stack trace:");
+    console.trace("[JWT] Set tokens stack trace");
+    console.log("[JWT] Setting tokens from response:", {
+      hasAccessToken: !!response.accessToken,
+      hasRefreshToken: !!response.refreshToken,
+      userId: response.userId,
+      expiresIn: response.expiresIn
+    });
+    const expiresAt = Date.now() + response.expiresIn * 1e3;
+    this.tokens = {
+      accessToken: response.accessToken,
+      refreshToken: response.refreshToken,
+      userId: response.userId,
+      expiresIn: response.expiresIn,
+      expiresAt,
+      hasKeyshare: response.hasKeyshare,
+      isNewUser: response.isNewUser,
+      avatar: response.avatar ?? null,
+      displayName: response.displayName ?? null
+    };
+    console.log("[JWT] Tokens object created");
+    await this.saveTokensToStorage();
+    console.log("[JWT] Tokens saved to storage successfully");
+  }
+  getAccessToken() {
+    if (!this.tokens) return null;
+    return this.tokens.accessToken;
+  }
+  getRefreshToken() {
+    return this.tokens?.refreshToken || null;
+  }
+  getUserId() {
+    return this.tokens?.userId || null;
+  }
+  getHasKeyshare() {
+    return this.tokens?.hasKeyshare ?? null;
+  }
+  getAvatar() {
+    return this.tokens?.avatar || null;
+  }
+  getDisplayName() {
+    return this.tokens?.displayName || null;
+  }
+  getTokens() {
+    return this.tokens;
+  }
+  async updateKeyshareStatus(hasKeyshare) {
+    if (this.tokens) {
+      this.tokens.hasKeyshare = hasKeyshare;
+      await this.saveTokensToStorage();
+    }
+  }
+  async updateDisplayName(displayName) {
+    if (this.tokens) {
+      this.tokens.displayName = displayName;
+      await this.saveTokensToStorage();
+    }
+  }
+  isTokenExpired() {
+    if (!this.tokens) {
+      console.log("[JWT] No tokens available, considering expired");
+      return true;
+    }
+    const buffer = 30 * 1e3;
+    const now = Date.now();
+    const expiresAt = this.tokens.expiresAt;
+    const isExpired = now > expiresAt - buffer;
+    console.log("[JWT] Token expiry check:", {
+      currentTime: now,
+      expiresAt,
+      buffer,
+      timeToExpiry: (expiresAt - now) / 1e3,
+      isExpired
+    });
+    return isExpired;
+  }
+  isAuthenticated() {
+    if (!this.tokens) return false;
+    if (!this.isTokenExpired()) {
+      return !!this.tokens.accessToken;
+    }
+    return !!this.tokens.refreshToken;
+  }
+  async clearTokens() {
+    console.log("[JWT] \u26A0\uFE0F clearTokens() called - Stack trace:");
+    console.trace("[JWT] Clear tokens stack trace");
+    console.log("[JWT] Clearing tokens from memory and storage");
+    this.tokens = null;
+    await this.storage.removeItem(TOKEN_STORAGE_KEY);
+    await this.storage.removeItem(USER_ID_KEY);
+  }
+  async refreshAccessToken() {
+    if (this.refreshPromise) {
+      console.log("[JWT] Refresh already in progress, waiting for existing operation...");
+      return this.refreshPromise;
+    }
+    const refreshToken = this.getRefreshToken();
+    if (!refreshToken) {
+      console.warn("[JWT] No refresh token available for refresh");
+      return false;
+    }
+    console.log("[JWT] Starting new token refresh operation...");
+    this.refreshPromise = (async () => {
+      try {
+        const response = await fetch(addProjectIdToUrl(`${getTssUrl()}/api/auth/refresh`), {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ refreshToken })
+        });
+        if (!response.ok) {
+          console.log("[JWT] Token refresh failed with status:", response.status);
+          if (response.status === 401) {
+            try {
+              const errorData = await response.json();
+              console.log("[JWT] Refresh 401 Error details:", errorData);
+              switch (errorData.error_code) {
+                case "SESSION_NOT_FOUND":
+                  console.log("[JWT] Refresh token session not found, clearing tokens");
+                  await this.clearTokens();
+                  return false;
+                case "INVALID_TOKEN":
+                default:
+                  console.log("[JWT] Invalid refresh token, clearing tokens");
+                  await this.clearTokens();
+                  return false;
+              }
+            } catch (parseError) {
+              console.warn("[JWT] Could not parse refresh 401 error response:", parseError);
+              await this.clearTokens();
+              return false;
+            }
+          } else {
+            console.log("[JWT] Non-401 error during refresh, keeping tokens (might be network error)");
+            return false;
+          }
+        }
+        const refreshResponse = await response.json();
+        console.log("[JWT] Token refresh successful, new expiry in:", refreshResponse.expiresIn, "seconds");
+        if (this.tokens) {
+          this.tokens.accessToken = refreshResponse.accessToken;
+          this.tokens.refreshToken = refreshResponse.refreshToken;
+          this.tokens.expiresIn = refreshResponse.expiresIn;
+          this.tokens.expiresAt = Date.now() + refreshResponse.expiresIn * 1e3;
+          await this.saveTokensToStorage();
+          console.log("[JWT] Refreshed tokens saved to storage");
+          return true;
+        }
+        console.error("[JWT] No existing tokens to update");
+        return false;
+      } catch (error) {
+        console.error("[JWT] Token refresh network error:", error);
+        return false;
+      } finally {
+        this.refreshPromise = null;
+        console.log("[JWT] Refresh operation completed, mutex cleared");
+      }
+    })();
+    return this.refreshPromise;
+  }
+  getAuthHeader() {
+    const token = this.getAccessToken();
+    return token ? `Bearer ${token}` : null;
+  }
+};
+var jwtTokenManager = new JwtTokenManager();
+function createJwtTokenManager(storage) {
+  return new JwtTokenManager(storage);
+}
+async function logout(manager = jwtTokenManager) {
+  try {
+    const authHeader = manager.getAuthHeader();
+    if (authHeader) {
+      await fetch(addProjectIdToUrl(`${getTssUrl()}/api/auth/logout`), {
+        method: "POST",
+        headers: {
+          Authorization: authHeader,
+          "Content-Type": "application/json"
+        }
+      });
+    }
+  } catch (error) {
+    console.error("[JWT] Logout error:", error);
+  } finally {
+    await manager.clearTokens();
+  }
+}
+async function verifyToken(manager = jwtTokenManager) {
+  const authHeader = manager.getAuthHeader();
+  if (!authHeader) {
+    console.log("[JWT] No auth header available for verification");
+    return { valid: false };
+  }
+  try {
+    const response = await fetch(addProjectIdToUrl(`${getTssUrl()}/api/auth/verify`), {
+      method: "GET",
+      headers: { Authorization: authHeader }
+    });
+    if (!response.ok) {
+      console.log("[JWT] Token verification failed:", response.status);
+      if (response.status === 401) {
+        try {
+          const errorData = await response.json();
+          console.log("[JWT] 401 Error details:", errorData);
+          switch (errorData.error_code) {
+            case "TOKEN_EXPIRED":
+              console.log("[JWT] Access token expired, attempting refresh...");
+              const refreshSuccess = await manager.refreshAccessToken();
+              if (refreshSuccess) {
+                console.log("[JWT] Token refreshed successfully, retrying verification");
+                return await verifyToken(manager);
+              } else {
+                console.log("[JWT] Token refresh failed, clearing tokens");
+                await manager.clearTokens();
+                return { valid: false };
+              }
+            case "SESSION_NOT_FOUND":
+              console.log("[JWT] Session not found or revoked, clearing tokens");
+              await manager.clearTokens();
+              return { valid: false };
+            case "INVALID_TOKEN":
+            default:
+              console.log("[JWT] Invalid token, clearing tokens");
+              await manager.clearTokens();
+              return { valid: false };
+          }
+        } catch (parseError) {
+          console.warn("[JWT] Could not parse 401 error response:", parseError);
+          await manager.clearTokens();
+          return { valid: false };
+        }
+      } else {
+        console.log("[JWT] Non-401 error during verification, keeping tokens");
+        return { valid: false };
+      }
+    }
+    const verifyResponse = await response.json();
+    console.log("[JWT] Token verification successful:", verifyResponse);
+    if (verifyResponse.valid) {
+      if (typeof verifyResponse.hasKeyshare === "boolean") {
+        await manager.updateKeyshareStatus(verifyResponse.hasKeyshare);
+      }
+      if (manager.getTokens()) {
+        if (verifyResponse.displayName !== void 0) {
+          await manager.updateDisplayName(verifyResponse.displayName);
+        }
+      }
+    }
+    return verifyResponse;
+  } catch (error) {
+    console.error("[JWT] Token verification network error:", error);
+    return { valid: false };
+  }
+}
+async function ensureValidToken(manager = jwtTokenManager) {
+  console.log("[JWT] ensureValidToken() called - Stack trace:");
+  console.trace("[JWT] ensureValidToken stack trace");
+  console.log("[JWT] Checking token validity...");
+  if (manager.isAuthenticated() && !manager.isTokenExpired()) {
+    console.log("[JWT] Access token is valid");
+    return true;
+  }
+  console.log("[JWT] Access token expired or missing, attempting refresh...");
+  const refreshToken = manager.getRefreshToken();
+  if (refreshToken) {
+    console.log("[JWT] Refresh token available, attempting to refresh access token");
+    const refreshSuccess = await manager.refreshAccessToken();
+    console.log("[JWT] Refresh attempt result:", refreshSuccess);
+    return refreshSuccess;
+  }
+  console.log("[JWT] No refresh token available, user needs to re-authenticate");
+  return false;
+}
+async function authenticatedFetch(url, options = {}, manager = jwtTokenManager) {
+  const hasValidToken = await ensureValidToken(manager);
+  if (!hasValidToken) {
+    throw new Error("No valid authentication token available");
+  }
+  const authHeader = manager.getAuthHeader();
+  if (!authHeader) {
+    throw new Error("Failed to get authentication header");
+  }
+  const urlWithProjectId = addProjectIdToUrl(url);
+  const requestOptions = {
+    ...options,
+    headers: {
+      ...options.headers,
+      Authorization: authHeader,
+      "Content-Type": "application/json"
+    }
+  };
+  const response = await fetch(urlWithProjectId, requestOptions);
+  if (response.status === 401) {
+    const refreshSuccess = await manager.refreshAccessToken();
+    if (refreshSuccess) {
+      const newAuthHeader = manager.getAuthHeader();
+      if (newAuthHeader) {
+        requestOptions.headers = {
+          ...requestOptions.headers,
+          Authorization: newAuthHeader
+        };
+        return fetch(urlWithProjectId, requestOptions);
+      }
+    }
+  }
+  return response;
+}
+async function loginWithUserId(userId) {
+  const response = await fetch(addProjectIdToUrl(`${getTssUrl()}/api/auth/login`), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ userId })
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "Login failed");
+    throw new Error(`Login failed: ${response.status} ${errorText}`);
+  }
+  const loginResponse = await response.json();
+  await jwtTokenManager.setTokens(loginResponse);
+  return loginResponse;
+}
+async function loginWithEmail(email, code) {
+  const response = await fetch(addProjectIdToUrl(`${getTssUrl()}/api/auth/email/verify-code`), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ email, code })
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "Email verification failed");
+    throw new Error(`Email verification failed: ${response.status} ${errorText}`);
+  }
+  const loginResponse = await response.json();
+  await jwtTokenManager.setTokens(loginResponse);
+  return loginResponse;
+}
+async function loginWithTelegram(telegramData) {
+  const response = await fetch(addProjectIdToUrl(`${getTssUrl()}/api/auth/telegram/login`), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(telegramData)
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "Telegram login failed");
+    throw new Error(`Telegram login failed: ${response.status} ${errorText}`);
+  }
+  const loginResponse = await response.json();
+  await jwtTokenManager.setTokens(loginResponse);
+  return loginResponse;
+}
+async function syncKeyshareStatus(manager = jwtTokenManager) {
+  try {
+    const verification = await verifyToken(manager);
+    if (verification?.valid && typeof verification.hasKeyshare === "boolean") {
+      return verification.hasKeyshare;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+export { JwtTokenManager, LocalStorageAdapter, MemoryStorage, arrayBufferToBase64, arrayBufferToBase64url, authenticatedFetch, base64urlToUint8Array, configureJwtModule, createJwtTokenManager, ensureValidToken, jwtTokenManager, loginWithEmail, loginWithTelegram, loginWithUserId, logout, storageGet, storageRemove, storageSet, syncKeyshareStatus, verifyToken };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map