spaps-sdk 1.0.1 → 1.1.0

package/dist/index.js

@@ -1,8 +1,13 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,929 +20,453 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// index.ts
-var index_exports = {};
-__export(index_exports, {
-  AuthService: () => AuthService,
-  HttpClient: () => HttpClient,
-  PaymentsService: () => PaymentsService,
-  SweetPotatoAPIError: () => SweetPotatoAPIError,
-  SweetPotatoSDK: () => SweetPotatoSDK,
-  TokenManager: () => TokenManager,
-  WalletUtils: () => WalletUtils,
-  createSweetPotatoSDK: () => createSweetPotatoSDK,
-  default: () => SweetPotatoSDK
+// src/permissions.ts
+var permissions_exports = {};
+__export(permissions_exports, {
+  DEFAULT_ADMIN_ACCOUNTS: () => DEFAULT_ADMIN_ACCOUNTS,
+  PermissionChecker: () => PermissionChecker,
+  canAccessAdmin: () => canAccessAdmin,
+  createPermissionChecker: () => createPermissionChecker,
+  defaultPermissionChecker: () => defaultPermissionChecker,
+  getRoleAwareErrorMessage: () => getRoleAwareErrorMessage,
+  getUserDisplay: () => getUserDisplay,
+  getUserRole: () => getUserRole,
+  hasPermission: () => hasPermission,
+  isAdminAccount: () => isAdminAccount
 });
-module.exports = __toCommonJS(index_exports);
-
-// types.ts
-var SweetPotatoAPIError = class extends Error {
-  constructor(message, code, status, details) {
-    super(message);
-    this.name = "SweetPotatoAPIError";
-    if (code !== void 0) this.code = code;
-    if (status !== void 0) this.status = status;
-    if (details !== void 0) this.details = details;
+function isAdminAccount(identifier, customAdmins = []) {
+  if (!identifier) return false;
+  const normalized = identifier.toLowerCase();
+  if (normalized === DEFAULT_ADMIN_ACCOUNTS.email.toLowerCase() || normalized === DEFAULT_ADMIN_ACCOUNTS.wallets.ethereum.toLowerCase() || normalized === DEFAULT_ADMIN_ACCOUNTS.wallets.solana.toLowerCase()) {
+    return true;
   }
-};
-
-// client.ts
-function detectLocalEnvironment() {
-  var _a;
-  if (typeof process !== "undefined" && process.env) {
-    if (process.env.NODE_ENV === "development" || process.env.SPAPS_LOCAL_MODE === "true") {
+  return customAdmins.some((admin) => {
+    if (typeof admin === "string") {
+      return admin.toLowerCase() === normalized;
+    }
+    if ("email" in admin && admin.email.toLowerCase() === normalized) {
       return true;
     }
+    if ("wallets" in admin) {
+      return Object.values(admin.wallets).some(
+        (wallet) => wallet.toLowerCase() === normalized
+      );
+    }
+    return false;
+  });
+}
+function getUserRole(identifier, customAdmins = []) {
+  if (!identifier) return "guest";
+  if (isAdminAccount(identifier, customAdmins)) {
+    return "admin";
   }
-  if (typeof globalThis !== "undefined" && ((_a = globalThis.window) == null ? void 0 : _a.location)) {
-    const hostname = globalThis.window.location.hostname;
-    return hostname === "localhost" || hostname === "127.0.0.1" || hostname.endsWith(".local");
+  return "user";
+}
+function hasPermission(user, requiredPermissions, customAdmins = []) {
+  if (!user) return false;
+  const identifier = user.email || user.wallet_address;
+  const userRole = getUserRole(identifier, customAdmins);
+  if (userRole === "admin") {
+    return true;
+  }
+  if (Array.isArray(requiredPermissions)) {
+    return requiredPermissions.every(
+      (permission) => user.permissions?.includes(permission)
+    );
   }
-  return false;
+  return user.permissions?.includes(requiredPermissions) || false;
 }
-var HttpClient = class {
-  constructor(config) {
-    var _a, _b;
-    const localMode = (_b = config.localMode) != null ? _b : ((_a = config.apiUrl) == null ? void 0 : _a.includes("localhost")) || detectLocalEnvironment();
-    this.config = {
-      timeout: 3e4,
-      retries: 3,
-      ...config,
-      localMode
+function canAccessAdmin(user, customAdmins = []) {
+  if (!user) {
+    return {
+      allowed: false,
+      reason: "Authentication required",
+      userRole: "guest",
+      requiredRole: "admin"
     };
-    this.isLocalMode = this.config.localMode || false;
-    this.accessToken = void 0;
-    if (this.isLocalMode && typeof console !== "undefined") {
-      console.log("[SPAPS SDK] Running in local development mode - authentication will be automatic");
-    }
   }
-  /**
-   * Set the access token for authenticated requests
-   */
-  setAccessToken(token) {
-    this.accessToken = token;
-  }
-  /**
-   * Clear the access token
-   */
-  clearAccessToken() {
-    this.accessToken = void 0;
+  const identifier = user.email || user.wallet_address;
+  const userRole = getUserRole(identifier, customAdmins);
+  const isAdmin = userRole === "admin";
+  return {
+    allowed: isAdmin,
+    reason: isAdmin ? void 0 : "Admin privileges required",
+    userRole,
+    requiredRole: "admin"
+  };
+}
+function getRoleAwareErrorMessage(requiredRole, userRole, action = "perform this action") {
+  const messages = {
+    admin: {
+      user: `\u{1F512} Admin privileges required to ${action}. Please authenticate with an admin account.`,
+      guest: `\u{1F510} Authentication required. Please sign in with an admin account to ${action}.`
+    },
+    user: {
+      guest: `\u{1F510} Authentication required. Please sign in to ${action}.`
+    }
+  };
+  return messages[requiredRole]?.[userRole] || `Access denied. Required role: ${requiredRole}, current role: ${userRole}`;
+}
+function getUserDisplay(user, customAdmins = []) {
+  if (!user) {
+    return {
+      displayName: "Guest",
+      role: "guest",
+      badge: null,
+      isAdmin: false
+    };
   }
-  /**
-   * Make an HTTP request with automatic retries and error handling
-   */
-  async request(options) {
-    var _a, _b, _c, _d;
-    const { method, url, data, headers = {}, requiresAuth = false } = options;
-    const fullUrl = url.startsWith("http") ? url : `${this.config.apiUrl.replace(/\/$/, "")}${url}`;
-    const requestHeaders = {
-      "Content-Type": "application/json",
-      ...headers
+  const identifier = user.email || user.wallet_address;
+  const role = getUserRole(identifier, customAdmins);
+  const isAdmin = role === "admin";
+  return {
+    displayName: user.email || `${user.wallet_address?.slice(0, 6)}...${user.wallet_address?.slice(-4)}` || "User",
+    role,
+    badge: isAdmin ? "\u{1F451} Admin" : null,
+    isAdmin
+  };
+}
+function createPermissionChecker(customAdmins = []) {
+  return new PermissionChecker(customAdmins);
+}
+var DEFAULT_ADMIN_ACCOUNTS, PermissionChecker, defaultPermissionChecker;
+var init_permissions = __esm({
+  "src/permissions.ts"() {
+    "use strict";
+    DEFAULT_ADMIN_ACCOUNTS = {
+      email: "buildooor@gmail.com",
+      wallets: {
+        ethereum: "0xa72bb7CeF1e4B2Cc144373d8dE0Add7CCc8DF4Ba",
+        solana: "HVEbdiYU3Rr34NHBSgKs7q8cvdTeZLqNL77Z1FB2vjLy"
+      }
     };
-    if (this.config.apiKey) {
-      requestHeaders["x-api-key"] = this.config.apiKey;
-    } else if (this.isLocalMode) {
-      requestHeaders["x-local-mode"] = "true";
-    } else {
-      console.warn("[SPAPS SDK] No API key provided and not in local mode");
-    }
-    if (requiresAuth && this.accessToken) {
-      requestHeaders["Authorization"] = `Bearer ${this.accessToken}`;
-    }
-    let lastError = null;
-    for (let attempt = 1; attempt <= this.config.retries; attempt++) {
-      try {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
-        const requestInit = {
-          method,
-          headers: requestHeaders,
-          signal: controller.signal
-        };
-        if (data && (method === "POST" || method === "PUT" || method === "PATCH")) {
-          requestInit.body = JSON.stringify(data);
-        }
-        const response = await fetch(fullUrl, requestInit);
-        clearTimeout(timeoutId);
-        if (!response) {
-          throw new Error("No response received");
-        }
-        let responseData;
-        const contentType = (_a = response.headers) == null ? void 0 : _a.get("content-type");
-        if (contentType && contentType.includes("application/json")) {
-          responseData = await response.json();
-        } else {
-          throw new SweetPotatoAPIError(
-            "Invalid response format: expected JSON",
-            "INVALID_RESPONSE_FORMAT",
-            response.status
-          );
+    PermissionChecker = class {
+      customAdmins;
+      constructor(customAdmins = []) {
+        this.customAdmins = customAdmins;
+      }
+      isAdmin(identifier) {
+        return isAdminAccount(identifier, this.customAdmins);
+      }
+      getRole(identifier) {
+        return getUserRole(identifier, this.customAdmins);
+      }
+      hasPermission(user, permissions) {
+        return hasPermission(user, permissions, this.customAdmins);
+      }
+      canAccessAdmin(user) {
+        return canAccessAdmin(user, this.customAdmins);
+      }
+      getErrorMessage(requiredRole, userRole, action) {
+        return getRoleAwareErrorMessage(requiredRole, userRole, action);
+      }
+      getUserDisplay(user) {
+        return getUserDisplay(user, this.customAdmins);
+      }
+      // Convenience methods
+      requiresAuth(user) {
+        return !user;
+      }
+      requiresAdmin(user) {
+        return !this.canAccessAdmin(user).allowed;
+      }
+      addCustomAdmin(admin) {
+        this.customAdmins.push(admin);
+      }
+      removeCustomAdmin(admin) {
+        this.customAdmins = this.customAdmins.filter((a) => a !== admin);
+      }
+    };
+    defaultPermissionChecker = new PermissionChecker();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_ADMIN_ACCOUNTS: () => DEFAULT_ADMIN_ACCOUNTS,
+  PermissionChecker: () => PermissionChecker,
+  SPAPS: () => SPAPSClient,
+  SPAPSClient: () => SPAPSClient,
+  SweetPotatoSDK: () => SPAPSClient,
+  canAccessAdmin: () => canAccessAdmin,
+  createPermissionChecker: () => createPermissionChecker,
+  default: () => index_default,
+  defaultPermissionChecker: () => defaultPermissionChecker,
+  getRoleAwareErrorMessage: () => getRoleAwareErrorMessage,
+  getUserDisplay: () => getUserDisplay,
+  getUserRole: () => getUserRole,
+  hasPermission: () => hasPermission,
+  isAdminAccount: () => isAdminAccount
+});
+module.exports = __toCommonJS(index_exports);
+var import_axios = __toESM(require("axios"));
+init_permissions();
+var SPAPSClient = class {
+  client;
+  apiKey;
+  accessToken;
+  refreshToken;
+  _isLocalMode = false;
+  // Admin namespace for cleaner API
+  admin = {
+    createProduct: (productData) => this.createProduct(productData),
+    updateProduct: (productId, updates) => this.updateProduct(productId, updates),
+    deleteProduct: (productId) => this.deleteProduct(productId),
+    createPrice: (priceData) => this.createPrice(priceData),
+    syncProducts: () => this.syncProducts(),
+    getProducts: () => this.getProducts()
+  };
+  constructor(config = {}) {
+    const apiUrl = config.apiUrl || process.env.SPAPS_API_URL || process.env.NEXT_PUBLIC_SPAPS_API_URL;
+    if (!apiUrl || apiUrl.includes("localhost") || apiUrl.includes("127.0.0.1")) {
+      this._isLocalMode = true;
+      this.client = import_axios.default.create({
+        baseURL: apiUrl || "http://localhost:3300",
+        timeout: config.timeout || 1e4,
+        headers: {
+          "Content-Type": "application/json"
         }
-        if (!(response == null ? void 0 : response.ok)) {
-          throw new SweetPotatoAPIError(
-            ((_b = responseData.error) == null ? void 0 : _b.message) || `HTTP ${response == null ? void 0 : response.status}: ${response == null ? void 0 : response.statusText}`,
-            ((_c = responseData.error) == null ? void 0 : _c.code) || "HTTP_ERROR",
-            response == null ? void 0 : response.status,
-            (_d = responseData.error) == null ? void 0 : _d.details
-          );
+      });
+    } else {
+      if (!config.apiKey && !process.env.SPAPS_API_KEY) {
+        console.warn("\u26A0\uFE0F SPAPS: No API key provided. Some features may not work.");
+      }
+      this.apiKey = config.apiKey || process.env.SPAPS_API_KEY;
+      this.client = import_axios.default.create({
+        baseURL: apiUrl,
+        timeout: config.timeout || 1e4,
+        headers: {
+          "Content-Type": "application/json",
+          ...this.apiKey && { "X-API-Key": this.apiKey }
         }
-        return responseData;
-      } catch (error) {
-        lastError = error;
-        if (error instanceof SweetPotatoAPIError) {
-          if (error.status && error.status >= 400 && error.status < 500) {
-            throw error;
+      });
+    }
+    this.client.interceptors.request.use((config2) => {
+      if (this.accessToken && !config2.headers.Authorization) {
+        config2.headers.Authorization = `Bearer ${this.accessToken}`;
+      }
+      return config2;
+    });
+    this.client.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        if (error.response?.status === 401 && this.refreshToken) {
+          try {
+            const { data } = await this.refresh(this.refreshToken);
+            this.accessToken = data.access_token;
+            this.refreshToken = data.refresh_token;
+            if (error.config) {
+              error.config.headers.Authorization = `Bearer ${this.accessToken}`;
+              return this.client.request(error.config);
+            }
+          } catch (refreshError) {
+            this.accessToken = void 0;
+            this.refreshToken = void 0;
           }
         }
-        if (attempt === this.config.retries) {
-          break;
-        }
-        const delayMs = Math.min(1e3 * Math.pow(2, attempt - 1), 1e4);
-        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        return Promise.reject(error);
       }
-    }
-    if (lastError instanceof SweetPotatoAPIError) {
-      throw lastError;
-    }
-    throw new SweetPotatoAPIError(
-      (lastError == null ? void 0 : lastError.message) || "Request failed after all retries",
-      "REQUEST_FAILED",
-      void 0,
-      { originalError: lastError }
     );
   }
-  /**
-   * Convenience method for GET requests
-   */
-  async get(url, requiresAuth = false) {
-    return this.request({
-      method: "GET",
-      url,
-      requiresAuth
-    });
-  }
-  /**
-   * Convenience method for POST requests
-   */
-  async post(url, data, requiresAuth = false) {
-    return this.request({
-      method: "POST",
-      url,
-      data,
-      requiresAuth
-    });
-  }
-  /**
-   * Convenience method for PUT requests
-   */
-  async put(url, data, requiresAuth = false) {
-    return this.request({
-      method: "PUT",
-      url,
-      data,
-      requiresAuth
-    });
-  }
-  /**
-   * Convenience method for DELETE requests
-   */
-  async delete(url, requiresAuth = false) {
-    return this.request({
-      method: "DELETE",
-      url,
-      requiresAuth
+  // Authentication Methods
+  async login(email, password) {
+    const response = await this.client.post("/api/auth/login", {
+      email,
+      password
     });
-  }
-};
-
-// auth.ts
-var AuthService = class {
-  constructor(httpClient) {
-    this.httpClient = httpClient;
-  }
-  /**
-   * Get a nonce for wallet signature
-   * @param walletAddress - The wallet address to generate a nonce for
-   * @returns Promise<NonceResponse>
-   */
-  async getNonce(walletAddress) {
-    var _a;
-    const response = await this.httpClient.post("/api/auth/nonce", {
-      wallet_address: walletAddress
+    this.accessToken = response.data.access_token;
+    this.refreshToken = response.data.refresh_token;
+    return response;
+  }
+  async register(email, password) {
+    const response = await this.client.post("/api/auth/register", {
+      email,
+      password
     });
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to generate nonce");
-    }
-    return response.data;
+    this.accessToken = response.data.access_token;
+    this.refreshToken = response.data.refresh_token;
+    return response;
   }
-  /**
-   * Sign in with wallet signature
-   * @param request - Wallet sign-in request data
-   * @returns Promise<AuthResponse>
-   */
-  async signInWithWallet(request) {
-    var _a;
-    const response = await this.httpClient.post("/api/auth/wallet-sign-in", request);
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Wallet sign-in failed");
-    }
-    this.httpClient.setAccessToken(response.data.access_token);
-    return response.data;
-  }
-  /**
-   * Complete wallet authentication flow
-   * This is a convenience method that combines getNonce and signInWithWallet
-   * @param walletAddress - The wallet address
-   * @param signatureFunction - Function that signs the auth message
-   * @param chainType - Optional chain type (will be auto-detected if not provided)
-   * @param username - Optional username for new users
-   * @returns Promise<AuthResponse>
-   */
-  async authenticateWallet(walletAddress, signatureFunction, chainType, username) {
-    const nonceData = await this.getNonce(walletAddress);
-    const signature = await signatureFunction(nonceData.message);
-    const request = {
+  async walletSignIn(walletAddress, signature, message, chainType = "solana") {
+    const response = await this.client.post("/api/auth/wallet-sign-in", {
       wallet_address: walletAddress,
       signature,
-      message: nonceData.message
-    };
-    if (chainType) {
-      request.chain_type = chainType;
-    }
-    if (username) {
-      request.username = username;
-    }
-    return this.signInWithWallet(request);
-  }
-  /**
-   * Sign in with email and password
-   * @param request - Traditional login request data
-   * @returns Promise<AuthResponse>
-   */
-  async signInWithPassword(request) {
-    var _a;
-    const response = await this.httpClient.post("/api/auth/login", request);
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Login failed");
-    }
-    this.httpClient.setAccessToken(response.data.access_token);
-    return response.data;
-  }
-  /**
-   * Request a magic link for email authentication
-   * @param request - Magic link request data
-   * @returns Promise<void>
-   */
-  async requestMagicLink(request) {
-    var _a;
-    const response = await this.httpClient.post("/api/auth/magic-link", request);
-    if (!response.success) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to send magic link");
-    }
+      message,
+      chain_type: chainType
+    });
+    this.accessToken = response.data.access_token;
+    this.refreshToken = response.data.refresh_token;
+    return response;
   }
-  /**
-   * Refresh access token using refresh token
-   * @param refreshToken - The refresh token
-   * @returns Promise<TokenPair>
-   */
-  async refreshToken(refreshToken) {
-    var _a;
-    const response = await this.httpClient.post("/api/auth/refresh", {
-      refresh_token: refreshToken
+  async refresh(refreshToken) {
+    const response = await this.client.post("/api/auth/refresh", {
+      refresh_token: refreshToken || this.refreshToken
     });
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Token refresh failed");
-    }
-    this.httpClient.setAccessToken(response.data.access_token);
-    return response.data;
+    this.accessToken = response.data.access_token;
+    this.refreshToken = response.data.refresh_token;
+    return response;
   }
-  /**
-   * Log out and invalidate tokens
-   * @returns Promise<void>
-   */
   async logout() {
-    var _a;
-    try {
-      const response = await this.httpClient.post("/api/auth/logout", {}, true);
-      if (!response.success) {
-        console.warn("Logout API call failed:", ((_a = response.error) == null ? void 0 : _a.message) || "Unknown error");
-      }
-    } catch (error) {
-      console.warn("Logout API call failed:", error);
-    } finally {
-      this.httpClient.clearAccessToken();
-    }
-  }
-  /**
-   * Get current user profile
-   * @returns Promise<User>
-   */
-  async getCurrentUser() {
-    var _a;
-    const response = await this.httpClient.get("/api/auth/user", true);
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to get user profile");
-    }
-    return response.data.user;
-  }
-  /**
-   * Check if user is currently authenticated
-   * @returns boolean
-   */
-  isAuthenticated() {
-    return this.httpClient["accessToken"] !== void 0;
-  }
-  /**
-   * Clear authentication state (useful for client-side logout)
-   */
-  clearAuth() {
-    this.httpClient.clearAccessToken();
-  }
-};
-
-// payments.ts
-var PaymentsService = class {
-  constructor(httpClient) {
-    this.httpClient = httpClient;
-  }
-  // Checkout Sessions
-  /**
-   * Create a new Stripe checkout session
-   * @param request - Checkout session creation parameters
-   * @returns Promise<CheckoutSession>
-   */
-  async createCheckoutSession(request) {
-    var _a;
-    const response = await this.httpClient.post(
-      "/api/stripe/checkout-sessions",
-      request,
-      true
-    );
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to create checkout session");
-    }
-    return response.data;
-  }
-  /**
-   * Retrieve a checkout session by ID
-   * @param sessionId - The checkout session ID
-   * @returns Promise<CheckoutSession>
-   */
-  async getCheckoutSession(sessionId) {
-    var _a;
-    const response = await this.httpClient.get(
-      `/api/stripe/checkout-sessions/${sessionId}`,
-      true
-    );
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to retrieve checkout session");
-    }
-    return response.data;
-  }
-  /**
-   * Expire a checkout session
-   * @param sessionId - The checkout session ID to expire
-   * @returns Promise<{id: string, status: string, expired: boolean}>
-   */
-  async expireCheckoutSession(sessionId) {
-    var _a;
-    const response = await this.httpClient.post(
-      `/api/stripe/checkout-sessions/${sessionId}/expire`,
-      {},
-      true
-    );
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to expire checkout session");
-    }
-    return response.data;
-  }
-  /**
-   * List checkout sessions for the current user
-   * @param options - List options (limit, pagination)
-   * @returns Promise<CheckoutSessionListResponse>
-   */
-  async listCheckoutSessions(options = {}) {
-    var _a;
-    const params = new URLSearchParams();
-    if (options.limit) params.append("limit", options.limit.toString());
-    if (options.starting_after) params.append("starting_after", options.starting_after);
-    const url = `/api/stripe/checkout-sessions${params.toString() ? `?${params.toString()}` : ""}`;
-    const response = await this.httpClient.get(url, true);
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to list checkout sessions");
-    }
-    return response.data;
-  }
-  // Products
-  /**
-   * List available products
-   * @param request - Product list filters
-   * @returns Promise<ProductsListResponse>
-   */
-  async listProducts(request = {}) {
-    var _a;
-    const params = new URLSearchParams();
-    if (request.category) params.append("category", request.category);
-    if (request.active !== void 0) params.append("active", request.active.toString());
-    if (request.limit) params.append("limit", request.limit.toString());
-    if (request.starting_after) params.append("starting_after", request.starting_after);
-    const url = `/api/stripe/products${params.toString() ? `?${params.toString()}` : ""}`;
-    const response = await this.httpClient.get(url, true);
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to list products");
-    }
-    return response.data;
-  }
-  /**
-   * Get a specific product by ID
-   * @param productId - The product ID
-   * @param includePrices - Whether to include associated prices (default: true)
-   * @returns Promise<StripeProduct>
-   */
-  async getProduct(productId, includePrices = true) {
-    var _a;
-    const params = new URLSearchParams();
-    if (!includePrices) params.append("include_prices", "false");
-    const url = `/api/stripe/products/${productId}${params.toString() ? `?${params.toString()}` : ""}`;
-    const response = await this.httpClient.get(url, true);
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to retrieve product");
-    }
-    return response.data;
-  }
-  /**
-   * Create a new product (Admin only)
-   * @param request - Product creation parameters
-   * @returns Promise<StripeProduct>
-   */
-  async createProduct(request) {
-    var _a;
-    const response = await this.httpClient.post(
-      "/api/stripe/products",
-      request,
-      true
-    );
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to create product");
-    }
-    return response.data;
-  }
-  /**
-   * Update an existing product (Admin only)
-   * @param productId - The product ID to update
-   * @param request - Product update parameters
-   * @returns Promise<StripeProduct>
-   */
-  async updateProduct(productId, request) {
-    var _a;
-    const response = await this.httpClient.put(
-      `/api/stripe/products/${productId}`,
-      request,
-      true
-    );
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to update product");
-    }
-    return response.data;
-  }
-  /**
-   * Archive a product (Admin only)
-   * @param productId - The product ID to archive
-   * @returns Promise<{id: string, archived: boolean, active: boolean}>
-   */
-  async archiveProduct(productId) {
-    var _a;
-    const response = await this.httpClient.delete(
-      `/api/stripe/products/${productId}`,
-      true
-    );
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to archive product");
-    }
-    return response.data;
-  }
-  /**
-   * Sync products from Stripe (Admin only)
-   * @returns Promise<{synced_count: number, message: string}>
-   */
-  async syncProducts() {
-    var _a;
-    const response = await this.httpClient.post(
-      "/api/stripe/products/sync",
-      {},
-      true
-    );
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to sync products");
-    }
-    return response.data;
+    await this.client.post("/api/auth/logout");
+    this.accessToken = void 0;
+    this.refreshToken = void 0;
   }
-  // Prices
-  /**
-   * Create a new price for a product (Admin only)
-   * @param request - Price creation parameters
-   * @returns Promise<StripePrice>
-   */
-  async createPrice(request) {
-    var _a;
-    const response = await this.httpClient.post(
-      "/api/stripe/prices",
-      request,
-      true
-    );
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to create price");
-    }
-    return response.data;
+  async getUser() {
+    return this.client.get("/api/auth/user");
   }
-  // Subscriptions
-  /**
-   * Create a new subscription
-   * @param request - Subscription creation parameters
-   * @returns Promise<Subscription>
-   */
-  async createSubscription(request) {
-    var _a;
-    const response = await this.httpClient.post(
-      "/api/stripe/subscriptions",
-      request,
-      true
-    );
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to create subscription");
-    }
-    return response.data;
+  // Stripe Methods
+  async createCheckoutSession(priceId, successUrl, cancelUrl) {
+    return this.client.post("/api/stripe/create-checkout-session", {
+      price_id: priceId,
+      success_url: successUrl,
+      cancel_url: cancelUrl
+    });
   }
-  /**
-   * Get a subscription by ID
-   * @param subscriptionId - The subscription ID
-   * @returns Promise<Subscription>
-   */
-  async getSubscription(subscriptionId) {
-    var _a;
-    const response = await this.httpClient.get(
-      `/api/stripe/subscriptions/${subscriptionId}`,
-      true
-    );
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to retrieve subscription");
-    }
-    return response.data;
+  async getSubscription() {
+    return this.client.get("/api/stripe/subscription");
   }
-  /**
-   * List subscriptions for the current user
-   * @param options - List options
-   * @returns Promise<{subscriptions: Subscription[], has_more: boolean}>
-   */
-  async listSubscriptions(options = {}) {
-    var _a;
-    const params = new URLSearchParams();
-    if (options.limit) params.append("limit", options.limit.toString());
-    if (options.starting_after) params.append("starting_after", options.starting_after);
-    if (options.status) params.append("status", options.status);
-    const url = `/api/stripe/subscriptions${params.toString() ? `?${params.toString()}` : ""}`;
-    const response = await this.httpClient.get(url, true);
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to list subscriptions");
-    }
-    return response.data;
+  async cancelSubscription() {
+    await this.client.delete("/api/stripe/subscription");
   }
-  /**
-   * Cancel a subscription
-   * @param subscriptionId - The subscription ID to cancel
-   * @returns Promise<Subscription>
-   */
-  async cancelSubscription(subscriptionId) {
-    var _a;
-    const response = await this.httpClient.post(
-      `/api/stripe/subscriptions/${subscriptionId}/cancel`,
-      {},
-      true
-    );
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to cancel subscription");
-    }
-    return response.data;
+  // Usage Methods
+  async getUsageBalance() {
+    return this.client.get("/api/usage/balance");
   }
-  /**
-   * Update a subscription
-   * @param subscriptionId - The subscription ID to update
-   * @param request - Update parameters
-   * @returns Promise<Subscription>
-   */
-  async updateSubscription(subscriptionId, request) {
-    var _a;
-    const response = await this.httpClient.put(
-      `/api/stripe/subscriptions/${subscriptionId}`,
-      request,
-      true
-    );
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to update subscription");
-    }
-    return response.data;
+  async recordUsage(feature, amount) {
+    await this.client.post("/api/usage/record", {
+      feature,
+      amount
+    });
   }
-  // Customer Portal
+  // Admin Methods (Require admin privileges)
   /**
-   * Create a customer portal session
-   * @param request - Portal session parameters
-   * @returns Promise<CustomerPortalSession>
+   * Create a new Stripe product (Admin required)
    */
-  async createCustomerPortalSession(request) {
-    var _a;
-    const response = await this.httpClient.post(
-      "/api/stripe/customer-portal",
-      request,
-      true
-    );
-    if (!response.success || !response.data) {
-      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to create customer portal session");
+  async createProduct(productData) {
+    if (!this.accessToken) {
+      throw new Error("Authentication required. Please authenticate first.");
     }
-    return response.data;
+    return this.client.post("/api/stripe/products", productData, {
+      headers: {
+        "Authorization": `Bearer ${this.accessToken}`
+      }
+    });
   }
-  // Utility Methods
   /**
-   * Create a one-time payment checkout session
-   * Convenience method for simple one-time payments
-   * @param params - Payment parameters
-   * @returns Promise<CheckoutSession>
+   * Update an existing Stripe product (Admin required)
    */
-  async createPaymentCheckout(params) {
-    const lineItems = [];
-    if (params.price_id) {
-      lineItems.push({
-        price_id: params.price_id,
-        quantity: params.quantity || 1
-      });
-    } else if (params.product_name && params.amount && params.currency) {
-      lineItems.push({
-        quantity: params.quantity || 1,
-        price_data: {
-          currency: params.currency,
-          unit_amount: params.amount,
-          product_data: {
-            name: params.product_name
-          }
-        }
-      });
-    } else {
-      throw new Error("Either price_id or (product_name, amount, currency) must be provided");
+  async updateProduct(productId, updates) {
+    if (!this.accessToken) {
+      throw new Error("Authentication required. Please authenticate first.");
     }
-    return this.createCheckoutSession({
-      mode: "payment",
-      line_items: lineItems,
-      success_url: params.success_url,
-      cancel_url: params.cancel_url,
-      ...params.metadata && { metadata: params.metadata }
+    return this.client.put(`/api/stripe/products/${productId}`, updates, {
+      headers: {
+        "Authorization": `Bearer ${this.accessToken}`
+      }
     });
   }
   /**
-   * Create a subscription checkout session
-   * Convenience method for subscription creation
-   * @param params - Subscription parameters
-   * @returns Promise<CheckoutSession>
+   * Archive (soft delete) a Stripe product (Admin required)
    */
-  async createSubscriptionCheckout(params) {
-    return this.createCheckoutSession({
-      mode: "subscription",
-      line_items: [{
-        price_id: params.price_id,
-        quantity: 1
-      }],
-      success_url: params.success_url,
-      cancel_url: params.cancel_url,
-      subscription_data: {
-        ...params.trial_period_days !== void 0 && { trial_period_days: params.trial_period_days },
-        ...params.metadata && { metadata: params.metadata }
+  async deleteProduct(productId) {
+    if (!this.accessToken) {
+      throw new Error("Authentication required. Please authenticate first.");
+    }
+    return this.client.delete(`/api/stripe/products/${productId}`, {
+      headers: {
+        "Authorization": `Bearer ${this.accessToken}`
       }
     });
   }
-};
-
-// index.ts
-var SweetPotatoSDK = class {
-  constructor(config) {
-    if (!config.apiUrl) {
-      throw new Error("apiUrl is required");
-    }
-    this.httpClient = new HttpClient(config);
-    this.auth = new AuthService(this.httpClient);
-    this.payments = new PaymentsService(this.httpClient);
-    this.isLocalMode = this.httpClient["isLocalMode"] || false;
-    if (this.isLocalMode) {
-      console.log("[SPAPS SDK] Initialized in local development mode");
-      console.log("[SPAPS SDK] API URL:", config.apiUrl);
-      console.log("[SPAPS SDK] Authentication will be automatic");
-    }
-  }
   /**
-   * Set access token for authenticated requests
-   * @param token - Access token
+   * Create a new price for a product (Admin required)
    */
-  setAccessToken(token) {
-    this.httpClient.setAccessToken(token);
-  }
-  /**
-   * Clear access token
-   */
-  clearAccessToken() {
-    this.httpClient.clearAccessToken();
-  }
-  /**
-   * Get SDK configuration
-   */
-  getConfig() {
-    return {
-      apiUrl: this.httpClient["config"].apiUrl,
-      timeout: this.httpClient["config"].timeout,
-      retries: this.httpClient["config"].retries
-    };
-  }
-  /**
-   * Health check endpoint
-   * @returns Promise<boolean>
-   */
-  async healthCheck() {
-    try {
-      const response = await this.httpClient.get("/api/health");
-      return response.success;
-    } catch (e) {
-      return false;
+  async createPrice(priceData) {
+    if (!this.accessToken) {
+      throw new Error("Authentication required. Please authenticate first.");
     }
-  }
-  /**
-   * Make a custom authenticated request
-   * This allows advanced users to make direct API calls not covered by the SDK
-   */
-  async request(method, url, data, requiresAuth = false) {
-    return this.httpClient.request({
-      method,
-      url,
-      data,
-      requiresAuth
+    return this.client.post("/api/stripe/prices", priceData, {
+      headers: {
+        "Authorization": `Bearer ${this.accessToken}`
+      }
     });
   }
-};
-function createSweetPotatoSDK(config) {
-  return new SweetPotatoSDK(config);
-}
-var _TokenManager = class _TokenManager {
   /**
-   * Get localStorage instance (browser or test environment)
+   * Sync all products from Stripe to local database (Super Admin required)
    */
-  static getStorage() {
-    var _a, _b;
-    if (typeof globalThis !== "undefined" && globalThis.localStorage) {
-      return globalThis.localStorage;
-    }
-    if (typeof globalThis !== "undefined" && ((_a = globalThis.window) == null ? void 0 : _a.localStorage)) {
-      return globalThis.window.localStorage;
-    }
-    if (typeof global !== "undefined" && ((_b = global.window) == null ? void 0 : _b.localStorage)) {
-      return global.window.localStorage;
+  async syncProducts() {
+    if (!this.accessToken) {
+      throw new Error("Authentication required. Please authenticate first.");
     }
-    return null;
+    return this.client.post("/api/stripe/products/sync", {}, {
+      headers: {
+        "Authorization": `Bearer ${this.accessToken}`
+      }
+    });
   }
   /**
-   * Store tokens in localStorage (browser only)
+   * Get products with admin metadata (if user is admin)
    */
-  static storeTokens(tokens) {
-    const localStorage = _TokenManager.getStorage();
-    if (localStorage) {
-      localStorage.setItem(_TokenManager.ACCESS_TOKEN_KEY, tokens.access_token);
-      localStorage.setItem(_TokenManager.REFRESH_TOKEN_KEY, tokens.refresh_token);
-      localStorage.setItem(_TokenManager.USER_KEY, JSON.stringify(tokens.user));
+  async getProducts() {
+    const headers = {};
+    if (this.accessToken) {
+      headers["Authorization"] = `Bearer ${this.accessToken}`;
     }
+    return this.client.get("/api/stripe/products", { headers });
   }
-  /**
-   * Get stored access token (browser only)
-   */
-  static getAccessToken() {
-    const localStorage = _TokenManager.getStorage();
-    return localStorage ? localStorage.getItem(_TokenManager.ACCESS_TOKEN_KEY) : null;
-  }
-  /**
-   * Get stored refresh token (browser only)
-   */
-  static getRefreshToken() {
-    const localStorage = _TokenManager.getStorage();
-    return localStorage ? localStorage.getItem(_TokenManager.REFRESH_TOKEN_KEY) : null;
+  // Utility Methods
+  isAuthenticated() {
+    return !!this.accessToken;
   }
-  /**
-   * Get stored user data (browser only)
-   */
-  static getStoredUser() {
-    const localStorage = _TokenManager.getStorage();
-    if (localStorage) {
-      const userData = localStorage.getItem(_TokenManager.USER_KEY);
-      return userData ? JSON.parse(userData) : null;
-    }
-    return null;
+  getAccessToken() {
+    return this.accessToken;
   }
-  /**
-   * Clear all stored tokens and user data (browser only)
-   */
-  static clearTokens() {
-    const localStorage = _TokenManager.getStorage();
-    if (localStorage) {
-      localStorage.removeItem(_TokenManager.ACCESS_TOKEN_KEY);
-      localStorage.removeItem(_TokenManager.REFRESH_TOKEN_KEY);
-      localStorage.removeItem(_TokenManager.USER_KEY);
-    }
-  }
-  /**
-   * Check if access token is expired (basic check, doesn't verify signature)
-   */
-  static isTokenExpired(token) {
-    try {
-      const parts = token.split(".");
-      if (parts.length !== 3 || !parts[1]) return true;
-      const payload = JSON.parse(atob(parts[1]));
-      const currentTime = Math.floor(Date.now() / 1e3);
-      return payload.exp < currentTime;
-    } catch (e) {
-      return true;
-    }
+  setAccessToken(token) {
+    this.accessToken = token;
   }
-  /**
-   * Auto-refresh token if needed
-   */
-  static async autoRefreshToken(sdk) {
-    const accessToken = _TokenManager.getAccessToken();
-    const refreshToken = _TokenManager.getRefreshToken();
-    if (!accessToken || !refreshToken) {
-      return false;
-    }
-    if (!_TokenManager.isTokenExpired(accessToken)) {
-      sdk.setAccessToken(accessToken);
-      return true;
-    }
-    try {
-      const newTokens = await sdk.auth.refreshToken(refreshToken);
-      _TokenManager.storeTokens(newTokens);
-      return true;
-    } catch (e) {
-      _TokenManager.clearTokens();
-      return false;
-    }
+  isLocalMode() {
+    return this._isLocalMode;
   }
-};
-_TokenManager.ACCESS_TOKEN_KEY = "sweet_potato_access_token";
-_TokenManager.REFRESH_TOKEN_KEY = "sweet_potato_refresh_token";
-_TokenManager.USER_KEY = "sweet_potato_user";
-var TokenManager = _TokenManager;
-var WalletUtils = class _WalletUtils {
   /**
-   * Detect chain type from wallet address
+   * Check if current user has admin privileges
+   * Note: This requires the user object from authentication
    */
-  static detectChainType(address) {
-    if (/^0x[a-fA-F0-9]{40}$/.test(address)) {
-      return "ethereum";
-    }
-    if (/^bc1[a-z0-9]{39,59}$/.test(address)) {
-      return "bitcoin";
-    }
-    if (/^[1-9A-HJ-NP-Za-km-z]{32}$/.test(address) || /^[1-9A-HJ-NP-Za-km-z]{44}$/.test(address)) {
-      return "solana";
-    }
-    if (/^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$/.test(address) && address.length >= 26 && address.length <= 35) {
-      return "bitcoin";
-    }
-    if (/^[1-9A-HJ-NP-Za-km-z]{35,44}$/.test(address)) {
-      return "solana";
-    }
-    return null;
+  isAdmin(user) {
+    if (!user) return false;
+    const identifier = user.email || user.wallet_address;
+    if (!identifier) return false;
+    const { isAdminAccount: isAdminAccount2 } = (init_permissions(), __toCommonJS(permissions_exports));
+    return isAdminAccount2(identifier);
   }
-  /**
-   * Validate wallet address format
-   */
-  static isValidAddress(address, chainType) {
-    if (!chainType) {
-      chainType = _WalletUtils.detectChainType(address) || "ethereum";
-    }
-    switch (chainType) {
-      case "solana":
-        return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address);
-      case "ethereum":
-      case "base":
-        return /^0x[a-fA-F0-9]{40}$/.test(address);
-      case "bitcoin":
-        return /^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$/.test(address) || /^bc1[a-z0-9]{39,59}$/.test(address);
-      default:
-        return false;
-    }
+  async health() {
+    return this.client.get("/health");
   }
 };
+var index_default = SPAPSClient;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AuthService,
-  HttpClient,
-  PaymentsService,
-  SweetPotatoAPIError,
+  DEFAULT_ADMIN_ACCOUNTS,
+  PermissionChecker,
+  SPAPS,
+  SPAPSClient,
   SweetPotatoSDK,
-  TokenManager,
-  WalletUtils,
-  createSweetPotatoSDK
+  canAccessAdmin,
+  createPermissionChecker,
+  defaultPermissionChecker,
+  getRoleAwareErrorMessage,
+  getUserDisplay,
+  getUserRole,
+  hasPermission,
+  isAdminAccount
 });