strapi-plugin-magic-link-v5 5.5.7 → 5.5.8

package/dist/server/index.mjs

@@ -357,38 +357,14 @@ _Falls du diesen Link nicht angefordert hast, ignoriere diese Nachricht._`,
   try {
     const licenseGuardService = strapi2.plugin("magic-link").service("license-guard");
     setTimeout(async () => {
-      const licenseStatus = await licenseGuardService.initialize();
-      if (!licenseStatus.valid && licenseStatus.demo) {
-        strapi2.log.warn("╔════════════════════════════════════════════════════════════════╗");
-        strapi2.log.warn("║  [WARNING] MAGIC LINK PLUGIN RUNNING IN DEMO MODE             ║");
-        strapi2.log.warn("║                                                                ║");
-        strapi2.log.warn("║  To activate, create a license via Admin UI:                  ║");
-        strapi2.log.warn("║  Go to Settings → Magic Link → License                        ║");
-        strapi2.log.warn("╚════════════════════════════════════════════════════════════════╝");
-      } else if (licenseStatus.valid) {
-        const pluginStore2 = strapi2.store({
-          type: "plugin",
-          name: "magic-link"
-        });
-        const storedKey = await pluginStore2.get({ key: "licenseKey" });
-        strapi2.log.info("╔════════════════════════════════════════════════════════════════╗");
-        strapi2.log.info("║  [SUCCESS] MAGIC LINK PLUGIN LICENSE ACTIVE                    ║");
-        strapi2.log.info("║                                                                ║");
-        if (licenseStatus.data) {
-          strapi2.log.info(`║  License: ${licenseStatus.data.licenseKey}                    ║`);
-          strapi2.log.info(`║  User: ${licenseStatus.data.firstName} ${licenseStatus.data.lastName}`.padEnd(66) + "║");
-          strapi2.log.info(`║  Email: ${licenseStatus.data.email}`.padEnd(66) + "║");
-        } else if (storedKey) {
-          strapi2.log.info(`║  License: ${storedKey} (Offline Mode)                         ║`);
-          strapi2.log.info(`║  Status: Grace Period Active                                  ║`);
-        }
-        strapi2.log.info("║                                                                ║");
-        strapi2.log.info("║  [AUTO] Pinging every 15 minutes                               ║");
-        strapi2.log.info("╚════════════════════════════════════════════════════════════════╝");
+      try {
+        await licenseGuardService.initialize();
+      } catch (initErr) {
+        strapi2.log.debug("[magic-link] license-guard initialize() warning:", initErr.message);
       }
     }, 3e3);
   } catch (error) {
-    strapi2.log.error("[ERROR] Error initializing License Guard:", error);
+    strapi2.log.debug("[magic-link] license-guard service not available at bootstrap:", error.message);
   }
   try {
     setTimeout(async () => {
@@ -416,12 +392,11 @@ _Falls du diesen Link nicht angefordert hast, ignoriere diese Nachricht._`,
 var destroy$1 = ({ strapi: strapi2 }) => {
   try {
     const licenseGuardService = strapi2.plugin("magic-link")?.service("license-guard");
-    if (licenseGuardService) {
+    if (licenseGuardService && typeof licenseGuardService.cleanup === "function") {
       licenseGuardService.cleanup();
-      strapi2.log.info("[SUCCESS] License Guard cleanup completed");
     }
   } catch (error) {
-    strapi2.log.error("[ERROR] Error during License Guard cleanup:", error);
+    strapi2.log.debug("[magic-link] license-guard cleanup warning:", error.message);
   }
 };
 var passwordlessCompat$2 = (config2, { strapi: strapi2 }) => {
@@ -1206,9 +1181,7 @@ var auth$1 = {
       return i18n.sendError(ctx, "token.invalid", 400);
     }
     const settings = await magicLink2.settings();
-    const licenseGuard2 = strapi.plugin("magic-link").service("license-guard");
-    const hasOTPFeature = await licenseGuard2.hasFeature("otp-email");
-    if (settings.otp_enabled && hasOTPFeature) {
+    if (settings.otp_enabled) {
       await strapi.documents("plugin::magic-link.token").update({
         documentId: token2.documentId,
         data: {
@@ -1675,7 +1648,6 @@ Thanks for joining. Your Magic Link is on the way.`,
     const { email: normalizedEmail, totpCode } = parseBody$1(loginWithTotpSchema, ctx.request.body);
     const magicLink2 = strapi.plugin("magic-link").service("magic-link");
     const otpService = strapi.plugin("magic-link").service("otp");
-    const licenseGuard2 = strapi.plugin("magic-link").service("license-guard");
     const rateLimiter2 = strapi.plugin("magic-link").service("rate-limiter");
     const userService = strapi.plugin("users-permissions").service("user");
     const jwtService = strapi.plugin("users-permissions").service("jwt");
@@ -1694,10 +1666,6 @@ Thanks for joining. Your Magic Link is on the way.`,
     if (!settings.totp_as_primary_auth) {
       return ctx.forbidden("TOTP login is not enabled");
     }
-    const hasFeature = await licenseGuard2.hasFeature("otp-totp");
-    if (!hasFeature) {
-      return ctx.forbidden("TOTP login requires Advanced license");
-    }
     const GENERIC_INVALID = "Invalid credentials";
     const users = await strapi.documents("plugin::users-permissions.user").findMany({
       filters: { email: normalizedEmail },
@@ -2870,49 +2838,43 @@ var jwt$1 = {
 };
 var license$1 = {
   /**
-   * Get current license status
+   * Returns the current license status. Always reports the plugin as
+   * usable; `hasKey` indicates whether the admin has activated a key.
+   *
+   * @route GET /magic-link/license/status
+   * @returns {{ success: true, valid: true, hasKey: boolean, data: object|null }}
    */
   async getStatus(ctx) {
     try {
       const licenseGuard2 = strapi.plugin("magic-link").service("license-guard");
-      const pluginStore = strapi.store({
-        type: "plugin",
-        name: "magic-link"
-      });
+      const pluginStore = strapi.store({ type: "plugin", name: "magic-link" });
       const licenseKey = await pluginStore.get({ key: "licenseKey" });
       if (!licenseKey) {
         return ctx.send({
-          success: false,
-          demo: true,
-          valid: false,
-          message: "No license found. Running in demo mode."
+          success: true,
+          valid: true,
+          // plugin is always usable in the marketplace build
+          hasKey: false,
+          data: null,
+          message: "Plugin is active. License key activation is optional."
         });
       }
-      const verification = await licenseGuard2.verifyLicense(licenseKey);
       const license2 = await licenseGuard2.getLicenseByKey(licenseKey);
       return ctx.send({
         success: true,
-        valid: verification.valid,
-        demo: false,
+        valid: true,
+        hasKey: true,
         data: {
           licenseKey,
           email: license2?.email || null,
           firstName: license2?.firstName || null,
           lastName: license2?.lastName || null,
-          isActive: license2?.isActive || false,
-          isExpired: license2?.isExpired || false,
-          isOnline: license2?.isOnline || false,
-          expiresAt: license2?.expiresAt,
-          lastPingAt: license2?.lastPingAt,
-          deviceName: license2?.deviceName,
-          deviceId: license2?.deviceId,
-          ipAddress: license2?.ipAddress,
-          features: {
-            premium: license2?.featurePremium || false,
-            advanced: license2?.featureAdvanced || false,
-            enterprise: license2?.featureEnterprise || false,
-            custom: license2?.featureCustom || false
-          },
+          isActive: license2?.isActive ?? true,
+          isExpired: license2?.isExpired ?? false,
+          expiresAt: license2?.expiresAt || null,
+          deviceName: license2?.deviceName || null,
+          deviceId: license2?.deviceId || null,
+          ipAddress: license2?.ipAddress || null,
           maxDevices: license2?.maxDevices || 1,
           currentDevices: license2?.currentDevices || 0
         }
@@ -2923,7 +2885,11 @@ var license$1 = {
     }
   },
   /**
-   * Auto-create license with logged-in admin user data
+   * Auto-create a license using the currently logged-in admin user's
+   * data. Best-effort: a remote failure simply leaves the install
+   * un-keyed, the plugin keeps working.
+   *
+   * @route POST /magic-link/license/auto-create
    */
   async autoCreate(ctx) {
     try {
@@ -2938,15 +2904,9 @@ var license$1 = {
         lastName: adminUser.lastname || "User"
       });
       if (!license2) {
-        return ctx.badRequest("Failed to create license");
+        return ctx.badRequest("License server unreachable. The plugin keeps working without a key.");
       }
       await licenseGuard2.storeLicenseKey(license2.licenseKey);
-      const pingInterval = licenseGuard2.startPinging(license2.licenseKey, 15);
-      strapi.licenseGuard = {
-        licenseKey: license2.licenseKey,
-        pingInterval,
-        data: license2
-      };
       return ctx.send({
         success: true,
         message: "License automatically created and activated",
@@ -2958,26 +2918,22 @@ var license$1 = {
     }
   },
   /**
-   * Create and activate a new license
+   * Create and activate a new license with explicit user details.
+   *
+   * @route POST /magic-link/license/create
    */
   async createAndActivate(ctx) {
     try {
-      const { email: email2, firstName, lastName } = ctx.request.body;
+      const { email: email2, firstName, lastName } = ctx.request.body || {};
       if (!email2 || !firstName || !lastName) {
         return ctx.badRequest("Email, firstName, and lastName are required");
       }
       const licenseGuard2 = strapi.plugin("magic-link").service("license-guard");
       const license2 = await licenseGuard2.createLicense({ email: email2, firstName, lastName });
       if (!license2) {
-        return ctx.badRequest("Failed to create license");
+        return ctx.badRequest("License server unreachable. The plugin keeps working without a key.");
       }
       await licenseGuard2.storeLicenseKey(license2.licenseKey);
-      const pingInterval = licenseGuard2.startPinging(license2.licenseKey, 15);
-      strapi.licenseGuard = {
-        licenseKey: license2.licenseKey,
-        pingInterval,
-        data: license2
-      };
       return ctx.send({
         success: true,
         message: "License created and activated successfully",
@@ -2989,39 +2945,40 @@ var license$1 = {
     }
   },
   /**
-   * Manually ping the current license
+   * Manual refresh: re-verifies the stored license once and returns the
+   * latest details. Replaces the periodic-ping endpoint that used to run
+   * every 15 minutes — admins can call this on demand from the UI to
+   * pull updated info.
+   *
+   * @route POST /magic-link/license/ping
    */
   async ping(ctx) {
     try {
-      const pluginStore = strapi.store({
-        type: "plugin",
-        name: "magic-link"
-      });
+      const pluginStore = strapi.store({ type: "plugin", name: "magic-link" });
       const licenseKey = await pluginStore.get({ key: "licenseKey" });
       if (!licenseKey) {
         return ctx.badRequest("No license key found");
       }
       const licenseGuard2 = strapi.plugin("magic-link").service("license-guard");
-      const pingResult = await licenseGuard2.pingLicense(licenseKey);
-      if (!pingResult) {
-        return ctx.badRequest("Ping failed");
-      }
+      const verification = await licenseGuard2.verifyLicense(licenseKey);
       return ctx.send({
         success: true,
-        message: "License pinged successfully",
-        data: pingResult
+        message: verification.valid ? "License refreshed successfully" : "License key could not be verified, but the plugin keeps working.",
+        data: verification.data
       });
     } catch (error) {
-      strapi.log.error("Error pinging license:", error);
-      return ctx.badRequest("Error pinging license");
+      strapi.log.error("Error refreshing license:", error);
+      return ctx.badRequest("Error refreshing license");
     }
   },
   /**
-  * Store and validate an existing license key
-  */
+   * Store and validate an existing license key.
+   *
+   * @route POST /magic-link/license/store-key
+   */
   async storeKey(ctx) {
     try {
-      const { licenseKey, email: email2 } = ctx.request.body;
+      const { licenseKey, email: email2 } = ctx.request.body || {};
       if (!licenseKey || !licenseKey.trim()) {
         return ctx.badRequest("License key is required");
       }
@@ -3033,26 +2990,35 @@ var license$1 = {
       const licenseGuard2 = strapi.plugin("magic-link").service("license-guard");
       const verification = await licenseGuard2.verifyLicense(trimmedKey);
       if (!verification.valid) {
-        strapi.log.warn(`[WARNING] Invalid license key attempted: ${trimmedKey.substring(0, 8)}...`);
+        if (verification.networkError) {
+          strapi.log.warn(
+            `[WARNING] License server unreachable during activation. Storing key anyway: ${trimmedKey.substring(0, 8)}...`
+          );
+          await licenseGuard2.storeLicenseKey(trimmedKey);
+          return ctx.send({
+            success: true,
+            message: "License key stored (license server was unreachable; will retry on the next manual refresh).",
+            data: { licenseKey: trimmedKey, email: trimmedEmail }
+          });
+        }
+        strapi.log.warn(`[WARNING] Invalid license key: ${trimmedKey.substring(0, 8)}...`);
         return ctx.badRequest("Invalid or expired license key");
       }
       const license2 = await licenseGuard2.getLicenseByKey(trimmedKey);
       if (!license2) {
-        strapi.log.warn(`[WARNING] License not found in database: ${trimmedKey.substring(0, 8)}...`);
+        strapi.log.warn(`[WARNING] License not found: ${trimmedKey.substring(0, 8)}...`);
         return ctx.badRequest("License not found");
       }
-      if (license2.email.toLowerCase() !== trimmedEmail) {
-        strapi.log.warn(`[WARNING] Email mismatch for license key: ${trimmedKey.substring(0, 8)}... (Attempted: ${trimmedEmail})`);
+      if (license2.email && license2.email.toLowerCase() !== trimmedEmail) {
+        strapi.log.warn(
+          `[WARNING] Email mismatch for license key: ${trimmedKey.substring(0, 8)}... (attempted: ${trimmedEmail})`
+        );
         return ctx.badRequest("Email address does not match this license key");
       }
       await licenseGuard2.storeLicenseKey(trimmedKey);
-      const pingInterval = licenseGuard2.startPinging(trimmedKey, 15);
-      strapi.licenseGuard = {
-        licenseKey: trimmedKey,
-        pingInterval,
-        data: verification.data
-      };
-      strapi.log.info(`[SUCCESS] Existing license key validated and stored: ${trimmedKey.substring(0, 8)}... (Email: ${trimmedEmail})`);
+      strapi.log.info(
+        `[SUCCESS] License key validated and stored: ${trimmedKey.substring(0, 8)}... (email: ${trimmedEmail})`
+      );
       return ctx.send({
         success: true,
         message: "License key validated and activated successfully",
@@ -3204,11 +3170,6 @@ var otp$3 = {
       if (!otpSettings.enabled) {
         return ctx.badRequest("OTP is not enabled");
       }
-      const licenseGuard2 = strapi.plugin("magic-link").service("license-guard");
-      const hasOTPFeature = await licenseGuard2.hasFeature("otp-email");
-      if (!hasOTPFeature) {
-        return ctx.forbidden("OTP feature requires Premium license or higher");
-      }
       const rlFail = await enforceOtpRateLimits(ctx, normalizedEmail, "send");
       if (rlFail) return ctx.tooManyRequests(rlFail.message);
       const pluginStore = strapi.store({ type: "plugin", name: "magic-link" });
@@ -3500,11 +3461,6 @@ var otp$3 = {
    */
   async setupTOTP(ctx) {
     try {
-      const licenseGuard2 = strapi.plugin("magic-link").service("license-guard");
-      const hasFeature = await licenseGuard2.hasFeature("otp-totp");
-      if (!hasFeature) {
-        return ctx.forbidden("TOTP feature requires Advanced or Enterprise license");
-      }
       const { email: email2, id: userId } = ctx.state.user;
       const otpService = strapi.plugin("magic-link").service("otp");
       const setupData = await otpService.setupTOTP(userId, email2);
@@ -3574,11 +3530,6 @@ var otp$3 = {
    */
   async generateBackupCodes(ctx) {
     try {
-      const licenseGuard2 = strapi.plugin("magic-link").service("license-guard");
-      const hasFeature = await licenseGuard2.hasFeature("otp-backup-codes");
-      if (!hasFeature) {
-        return ctx.forbidden("Backup codes feature requires Enterprise license");
-      }
       const { id: userId } = ctx.state.user;
       const otpService = strapi.plugin("magic-link").service("otp");
       const backupCodes = await otpService.generateBackupCodes(userId);
@@ -3748,61 +3699,6 @@ const passwordlessCompat = passwordlessCompat$2;
 var middlewares$1 = {
   "passwordless-compat": passwordlessCompat
 };
-const { PolicyError } = require$$1$1.errors;
-var licenseCheck$1 = async (policyContext, config2, { strapi: strapi2 }) => {
-  try {
-    const licenseGuard2 = strapi2.plugin("magic-link").service("license-guard");
-    const pluginStore = strapi2.store({ type: "plugin", name: "magic-link" });
-    const licenseKey = await pluginStore.get({ key: "licenseKey" });
-    if (!licenseKey) {
-      strapi2.log.warn("[ACCESS-DENIED] No license key found");
-      throw new PolicyError("No license found. Please activate the plugin first.", {
-        policy: "license-check",
-        errCode: "LICENSE_MISSING"
-      });
-    }
-    const verification = await licenseGuard2.verifyLicense(licenseKey, true);
-    if (!verification.valid) {
-      strapi2.log.warn("[ACCESS-DENIED] Invalid license");
-      throw new PolicyError("Invalid or expired license.", {
-        policy: "license-check",
-        errCode: "LICENSE_INVALID"
-      });
-    }
-    const license2 = await licenseGuard2.getLicenseByKey(licenseKey);
-    if (!license2) {
-      strapi2.log.warn("[ACCESS-DENIED] License not found in database");
-      throw new PolicyError("License not found. Please contact support.", {
-        policy: "license-check",
-        errCode: "LICENSE_NOT_FOUND"
-      });
-    }
-    if (!license2.isActive) {
-      strapi2.log.warn("[ACCESS-DENIED] License is inactive");
-      throw new PolicyError("License is inactive. Please activate your license.", {
-        policy: "license-check",
-        errCode: "LICENSE_INACTIVE"
-      });
-    }
-    if (license2.isExpired) {
-      strapi2.log.warn("[ACCESS-DENIED] License has expired");
-      throw new PolicyError("License has expired. Please renew your license.", {
-        policy: "license-check",
-        errCode: "LICENSE_EXPIRED"
-      });
-    }
-    return true;
-  } catch (error) {
-    if (error instanceof PolicyError) {
-      throw error;
-    }
-    strapi2.log.error("Error checking license:", error);
-    throw new PolicyError("Error verifying license. Please try again.", {
-      policy: "license-check",
-      errCode: "LICENSE_CHECK_ERROR"
-    });
-  }
-};
 var compatibilityCheck$1 = async (policyContext, config2, { strapi: strapi2 }) => {
   const pluginStore = strapi2.store({
     type: "plugin",
@@ -3824,10 +3720,8 @@ var compatibilityCheck$1 = async (policyContext, config2, { strapi: strapi2 }) =
   }
   return true;
 };
-const licenseCheck = licenseCheck$1;
 const compatibilityCheck = compatibilityCheck$1;
 var policies$1 = {
-  "license-check": licenseCheck,
   "compatibility-check": compatibilityCheck
 };
 var contentApi$1 = {
@@ -3839,7 +3733,7 @@ var contentApi$1 = {
       handler: "auth.login",
       config: {
         auth: false,
-        policies: ["plugin::magic-link.license-check"]
+        policies: []
       }
     },
     {
@@ -3848,7 +3742,7 @@ var contentApi$1 = {
       handler: "auth.sendLink",
       config: {
         auth: false,
-        policies: ["plugin::magic-link.license-check"]
+        policies: []
       }
     },
     // OTP Routes
@@ -3858,7 +3752,7 @@ var contentApi$1 = {
       handler: "otp.send",
       config: {
         auth: false,
-        policies: ["plugin::magic-link.license-check"]
+        policies: []
       }
     },
     {
@@ -3867,7 +3761,7 @@ var contentApi$1 = {
       handler: "otp.verify",
       config: {
         auth: false,
-        policies: ["plugin::magic-link.license-check"]
+        policies: []
       }
     },
     {
@@ -3876,7 +3770,7 @@ var contentApi$1 = {
       handler: "otp.resend",
       config: {
         auth: false,
-        policies: ["plugin::magic-link.license-check"]
+        policies: []
       }
     },
     // MFA Routes
@@ -3886,7 +3780,7 @@ var contentApi$1 = {
       handler: "auth.verifyMFATOTP",
       config: {
         auth: false,
-        policies: ["plugin::magic-link.license-check"]
+        policies: []
       }
     },
     {
@@ -3895,7 +3789,7 @@ var contentApi$1 = {
       handler: "auth.loginWithTOTP",
       config: {
         auth: false,
-        policies: ["plugin::magic-link.license-check"]
+        policies: []
       }
     }
   ]
@@ -4195,10 +4089,7 @@ var compatibility$1 = {
       handler: "auth.login",
       config: {
         auth: false,
-        policies: [
-          "plugin::magic-link.compatibility-check",
-          "plugin::magic-link.license-check"
-        ],
+        policies: ["plugin::magic-link.compatibility-check"],
         description: "Compatibility route for strapi-plugin-passwordless"
       }
     },
@@ -4209,10 +4100,7 @@ var compatibility$1 = {
       handler: "auth.sendLink",
       config: {
         auth: false,
-        policies: [
-          "plugin::magic-link.compatibility-check",
-          "plugin::magic-link.license-check"
-        ],
+        policies: ["plugin::magic-link.compatibility-check"],
         description: "Compatibility route for strapi-plugin-passwordless"
       }
     }
@@ -4854,265 +4742,8 @@ var store$1 = ({ strapi: strapi2 }) => ({
     return pluginStore.set({ key: "settings", value: settings });
   }
 });
-var features$1 = {
-  // FREE/DEMO Features
-  free: {
-    maxTokens: 100,
-    // 100 aktive Tokens gleichzeitig
-    maxSessions: 50,
-    // 50 aktive JWT Sessions
-    maxIPBans: 10,
-    // 10 gebannte IPs
-    features: [
-      "basic-magic-link",
-      // Basis Magic Link Auth
-      "email-templates",
-      // Basis Email Templates
-      "jwt-sessions",
-      // JWT Session Management
-      "ip-tracking",
-      // IP Tracking für Security
-      "rate-limiting",
-      // Basis Rate Limiting
-      "auto-user-creation",
-      // Auto User Creation
-      "token-management",
-      // Token Dashboard
-      "ip-bans"
-      // IP Ban Management
-    ]
-  },
-  // PREMIUM Features
-  premium: {
-    maxTokens: 1e3,
-    // 1000 aktive Tokens
-    maxSessions: 500,
-    // 500 aktive Sessions
-    maxIPBans: 100,
-    // 100 gebannte IPs
-    features: [
-      "basic-magic-link",
-      "email-templates",
-      "jwt-sessions",
-      "ip-tracking",
-      "rate-limiting",
-      "auto-user-creation",
-      "token-management",
-      "ip-bans",
-      "otp-email",
-      // Email OTP (6-digit code)
-      "mfa-totp",
-      // MFA: Magic Link + TOTP (Szenario 1)
-      "custom-email-templates",
-      // Custom HTML/Text Templates
-      "email-designer-integration",
-      // Email Designer 5 Support
-      "magic-mail-integration",
-      // MagicMail Integration
-      "advanced-rate-limiting",
-      // Custom Rate Limits
-      "session-management",
-      // Erweiterte Session Verwaltung
-      "bulk-operations",
-      // Bulk Token/Session Operations
-      "extended-logging",
-      // Erweiterte Login-Info Logs
-      "custom-redirect-urls"
-      // Custom Redirect URLs per Token
-    ]
-  },
-  // ADVANCED Features
-  advanced: {
-    maxTokens: -1,
-    // Unlimited
-    maxSessions: -1,
-    // Unlimited
-    maxIPBans: -1,
-    // Unlimited
-    features: [
-      "basic-magic-link",
-      "email-templates",
-      "jwt-sessions",
-      "ip-tracking",
-      "rate-limiting",
-      "auto-user-creation",
-      "token-management",
-      "ip-bans",
-      "otp-email",
-      "mfa-totp",
-      // MFA: Magic Link + TOTP (Szenario 1)
-      "otp-sms",
-      // SMS OTP via Twilio/Vonage
-      "otp-totp",
-      // TOTP (Authenticator Apps)
-      "totp-primary-login",
-      // Login with Email + TOTP only (Szenario 2)
-      "custom-email-templates",
-      "email-designer-integration",
-      "magic-mail-integration",
-      "advanced-rate-limiting",
-      "session-management",
-      "bulk-operations",
-      "extended-logging",
-      "custom-redirect-urls",
-      "webhook-notifications",
-      // Webhooks für Events
-      "api-access-tokens",
-      // API Tokens für Programmatic Access
-      "advanced-analytics",
-      // Analytics Dashboard
-      "custom-token-context",
-      // Custom Context Data in Tokens
-      "geolocation-tracking",
-      // GeoIP Tracking
-      "device-fingerprinting",
-      // Device Fingerprinting
-      "suspicious-login-alerts"
-      // Alerts für verdächtige Logins
-    ]
-  },
-  // ENTERPRISE Features
-  enterprise: {
-    maxTokens: -1,
-    maxSessions: -1,
-    maxIPBans: -1,
-    features: [
-      "basic-magic-link",
-      "email-templates",
-      "jwt-sessions",
-      "ip-tracking",
-      "rate-limiting",
-      "auto-user-creation",
-      "token-management",
-      "ip-bans",
-      "otp-email",
-      "mfa-totp",
-      // MFA: Magic Link + TOTP (Szenario 1)
-      "otp-sms",
-      "otp-totp",
-      "totp-primary-login",
-      // Login with Email + TOTP only (Szenario 2)
-      "otp-backup-codes",
-      // Backup Recovery Codes
-      "biometric-support",
-      // WebAuthn/FIDO2
-      "custom-email-templates",
-      "email-designer-integration",
-      "magic-mail-integration",
-      "advanced-rate-limiting",
-      "session-management",
-      "bulk-operations",
-      "extended-logging",
-      "custom-redirect-urls",
-      "webhook-notifications",
-      "api-access-tokens",
-      "advanced-analytics",
-      "custom-token-context",
-      "geolocation-tracking",
-      "device-fingerprinting",
-      "suspicious-login-alerts",
-      "sso-integration",
-      // SSO/SAML Integration
-      "ldap-sync",
-      // LDAP/AD Sync
-      "audit-logs",
-      // Vollständige Audit Logs
-      "compliance-reports",
-      // GDPR/SOC2 Reports
-      "priority-support",
-      // 24/7 Priority Support
-      "custom-security-rules",
-      // Custom Security Rules
-      "multi-tenant",
-      // Multi-Tenant Support
-      "white-label"
-      // White-Label Branding
-    ]
-  },
-  /**
-   * Check if a feature is available for given license tier
-   */
-  hasFeature(licenseData, featureName) {
-    if (!licenseData) {
-      return this.free.features.includes(featureName);
-    }
-    let isEnterprise = false;
-    let isAdvanced = false;
-    let isPremium = false;
-    if (licenseData.tier) {
-      isEnterprise = licenseData.tier === "enterprise";
-      isAdvanced = licenseData.tier === "advanced";
-      isPremium = licenseData.tier === "premium";
-    }
-    if (licenseData.features) {
-      isEnterprise = isEnterprise || licenseData.features.enterprise === true;
-      isAdvanced = isAdvanced || licenseData.features.advanced === true;
-      isPremium = isPremium || licenseData.features.premium === true;
-    }
-    if (licenseData.featureEnterprise === true) {
-      isEnterprise = true;
-    }
-    if (licenseData.featureAdvanced === true) {
-      isAdvanced = true;
-    }
-    if (licenseData.featurePremium === true) {
-      isPremium = true;
-    }
-    if (isEnterprise && this.enterprise.features.includes(featureName)) {
-      return true;
-    }
-    if (isAdvanced && this.advanced.features.includes(featureName)) {
-      return true;
-    }
-    if (isPremium && this.premium.features.includes(featureName)) {
-      return true;
-    }
-    return this.free.features.includes(featureName);
-  },
-  /**
-   * Get max allowed tokens for license tier
-   */
-  getMaxTokens(licenseData) {
-    if (!licenseData) return this.free.maxTokens;
-    if (licenseData.featureEnterprise === true || licenseData.features?.enterprise === true) return this.enterprise.maxTokens;
-    if (licenseData.featureAdvanced === true || licenseData.features?.advanced === true) return this.advanced.maxTokens;
-    if (licenseData.featurePremium === true || licenseData.features?.premium === true) return this.premium.maxTokens;
-    return this.free.maxTokens;
-  },
-  /**
-   * Get max allowed sessions for license tier
-   */
-  getMaxSessions(licenseData) {
-    if (!licenseData) return this.free.maxSessions;
-    if (licenseData.featureEnterprise === true || licenseData.features?.enterprise === true) return this.enterprise.maxSessions;
-    if (licenseData.featureAdvanced === true || licenseData.features?.advanced === true) return this.advanced.maxSessions;
-    if (licenseData.featurePremium === true || licenseData.features?.premium === true) return this.premium.maxSessions;
-    return this.free.maxSessions;
-  },
-  /**
-   * Get max allowed IP bans for license tier
-   */
-  getMaxIPBans(licenseData) {
-    if (!licenseData) return this.free.maxIPBans;
-    if (licenseData.featureEnterprise === true || licenseData.features?.enterprise === true) return this.enterprise.maxIPBans;
-    if (licenseData.featureAdvanced === true || licenseData.features?.advanced === true) return this.advanced.maxIPBans;
-    if (licenseData.featurePremium === true || licenseData.features?.premium === true) return this.premium.maxIPBans;
-    return this.free.maxIPBans;
-  },
-  /**
-   * Get tier name from license data
-   */
-  getTierName(licenseData) {
-    if (!licenseData) return "free";
-    if (licenseData.featureEnterprise === true || licenseData.features?.enterprise === true) return "enterprise";
-    if (licenseData.featureAdvanced === true || licenseData.features?.advanced === true) return "advanced";
-    if (licenseData.featurePremium === true || licenseData.features?.premium === true) return "premium";
-    return "free";
-  }
-};
 const crypto$1 = require$$0$3;
 const os = require$$1$3;
-const features = features$1;
 const LICENSE_SERVER_URL = "https://magicapi.fitlex.me";
 const envTimeout = Number(process.env.MAGIC_LICENSE_TIMEOUT_MS);
 const DEFAULT_FETCH_TIMEOUT_MS = Number.isFinite(envTimeout) && envTimeout > 0 ? envTimeout : 12e3;
@@ -5120,7 +4751,7 @@ const FETCH_RETRIES = 1;
 const FETCH_RETRY_BACKOFF_MS = 750;
 async function fetchWithTimeout(url, options2 = {}, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
   let lastError;
-  for (let attempt = 0; attempt <= FETCH_RETRIES; attempt++) {
+  for (let attempt = 0; attempt <= FETCH_RETRIES; attempt += 1) {
     const controller2 = new AbortController();
     const timer = setTimeout(() => controller2.abort(), timeoutMs);
     try {
@@ -5139,15 +4770,22 @@ async function fetchWithTimeout(url, options2 = {}, timeoutMs = DEFAULT_FETCH_TI
   throw lastError;
 }
 var licenseGuard$1 = ({ strapi: strapi2 }) => ({
+  // ======================================================================
+  // Network helpers (used only during admin-side key activation)
+  // ======================================================================
   /**
-   * Get license server URL (hardcoded and immutable for security)
-   * @returns {string} The fixed license server URL
+   * License server URL. Hard-coded — kept simple because the only call
+   * site is the admin-side activation form. Not user-configurable.
+   * @returns {string}
    */
   getLicenseServerUrl() {
     return LICENSE_SERVER_URL;
   },
   /**
-   * Generate a unique device ID based on machine identifiers
+   * Hashed device identifier used by the upstream activation server to
+   * de-duplicate seats. Hash of MAC addresses + hostname; the raw values
+   * never leave the host.
+   * @returns {string}
    */
   generateDeviceId() {
     try {
@@ -5164,11 +4802,12 @@ var licenseGuard$1 = ({ strapi: strapi2 }) => ({
       return crypto$1.createHash("sha256").update(identifier).digest("hex").substring(0, 32);
     } catch (error) {
       strapi2.log.error("Error generating device ID:", error);
-      return crypto$1.randomBytes(16).digest("hex");
+      return crypto$1.randomBytes(16).toString("hex");
     }
   },
   /**
-   * Get device name
+   * Friendly device name for the activation payload.
+   * @returns {string}
    */
   getDeviceName() {
     try {
@@ -5178,7 +4817,9 @@ var licenseGuard$1 = ({ strapi: strapi2 }) => ({
     }
   },
   /**
-   * Get server IP address
+   * First non-internal IPv4 address. Best-effort, used in the activation
+   * payload only.
+   * @returns {string}
    */
   getIpAddress() {
     try {
@@ -5196,13 +4837,22 @@ var licenseGuard$1 = ({ strapi: strapi2 }) => ({
     }
   },
   /**
-   * Get user agent (server context)
+   * Server-side user-agent string for the activation payload.
+   * @returns {string}
    */
   getUserAgent() {
     return `Strapi/${strapi2.config.info.strapi} Node/${process.version} ${os.platform()}/${os.release()}`;
   },
+  // ======================================================================
+  // License creation / verification (admin activation path only)
+  // ======================================================================
   /**
-   * Create a license
+   * Create a license on the upstream activation server. Used by the
+   * admin "auto-create" / "create" flows. Failure to create is non-fatal
+   * — the plugin keeps working, the user just doesn't get a key.
+   *
+   * @param {{ email: string, firstName?: string, lastName?: string }} args
+   * @returns {Promise<object|null>} Upstream license payload, or null on failure
    */
   async createLicense({ email: email2, firstName, lastName }) {
     try {
@@ -5213,9 +4863,7 @@ var licenseGuard$1 = ({ strapi: strapi2 }) => ({
       const licenseServerUrl = this.getLicenseServerUrl();
       const response = await fetchWithTimeout(`${licenseServerUrl}/api/licenses/create`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
+        headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
           email: email2,
           firstName,
@@ -5230,390 +4878,201 @@ var licenseGuard$1 = ({ strapi: strapi2 }) => ({
       });
       const data = await response.json();
       if (data.success) {
-        strapi2.log.info("[SUCCESS] License created successfully:", data.data.licenseKey);
+        strapi2.log.info("[SUCCESS] License created:", data.data.licenseKey);
         return data.data;
-      } else {
-        strapi2.log.error("[ERROR] License creation failed:", data);
-        return null;
       }
+      strapi2.log.warn("[WARNING] License creation rejected by server:", data.message || "unknown");
+      return null;
     } catch (error) {
-      strapi2.log.error("[ERROR] Error creating license:", error);
+      strapi2.log.error("[ERROR] Error creating license:", error.message);
       return null;
     }
   },
   /**
-   * Verify a license (with grace period support)
+   * Verify a license against the upstream activation server.
+   * Called once when the admin saves a license key — never during
+   * runtime feature checks, never on a schedule.
+   *
+   * @param {string} licenseKey
+   * @returns {Promise<{valid: boolean, data: object|null}>}
    */
-  async verifyLicense(licenseKey, allowGracePeriod = false) {
+  async verifyLicense(licenseKey) {
     try {
-      const controller2 = new AbortController();
-      const timeoutId = setTimeout(() => controller2.abort(), 5e3);
       const licenseServerUrl = this.getLicenseServerUrl();
       const response = await fetchWithTimeout(`${licenseServerUrl}/api/licenses/verify`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
+        headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
           licenseKey,
           pluginName: "magic-link",
           productName: "Magic Link - Passwordless Authentication"
-        }),
-        signal: controller2.signal
+        })
       });
-      clearTimeout(timeoutId);
       const data = await response.json();
       if (data.success) {
-        const isValid = data.data.isActive && !data.data.isExpired;
+        const isValid = !!(data.data && data.data.isActive && !data.data.isExpired);
         if (isValid) {
-          const pluginStore = strapi2.store({
-            type: "plugin",
-            name: "magic-link"
-          });
+          const pluginStore = strapi2.store({ type: "plugin", name: "magic-link" });
           await pluginStore.set({ key: "lastValidated", value: (/* @__PURE__ */ new Date()).toISOString() });
         }
-        return {
-          valid: isValid,
-          data: data.data
-        };
-      } else {
-        strapi2.log.warn(`[WARNING] License verification failed: ${data.message || "Unknown error"} (Key: ${licenseKey?.substring(0, 8)}...)`);
-        return { valid: false, data: null };
-      }
-    } catch (error) {
-      if (allowGracePeriod) {
-        strapi2.log.warn(`[WARNING] Cannot verify license online: ${error.message} (Key: ${licenseKey?.substring(0, 8)}...)`);
-        strapi2.log.info(`[INFO] Grace period active - accepting stored license key`);
-        return { valid: true, data: null, gracePeriod: true };
+        return { valid: isValid, data: data.data };
       }
-      strapi2.log.error(`[ERROR] Error verifying license: ${error.message} (Key: ${licenseKey?.substring(0, 8)}...)`);
+      strapi2.log.warn(
+        `[WARNING] License verification failed: ${data.message || "Unknown error"} (Key: ${licenseKey?.substring(0, 8)}...)`
+      );
       return { valid: false, data: null };
-    }
-  },
-  /**
-   * Ping a license (lightweight check)
-   */
-  async pingLicense(licenseKey) {
-    try {
-      const licenseServerUrl = this.getLicenseServerUrl();
-      const response = await fetchWithTimeout(`${licenseServerUrl}/api/licenses/ping`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          licenseKey,
-          pluginName: "magic-link",
-          productName: "Magic Link - Passwordless Authentication"
-        })
-      });
-      const data = await response.json();
-      if (data.success) {
-        strapi2.log.debug(`[PING] License ping successful: ${data.data?.isActive ? "ACTIVE" : "INACTIVE"} (Key: ${licenseKey?.substring(0, 8)}...)`);
-        return data.data;
-      } else {
-        strapi2.log.debug(`[WARNING] License ping failed: ${data.message || "Unknown error"} (Key: ${licenseKey?.substring(0, 8)}...)`);
-        return null;
-      }
     } catch (error) {
-      strapi2.log.debug(`License ping error: ${error.message} (Key: ${licenseKey?.substring(0, 8)}...)`);
-      return null;
-    }
-  },
-  /**
-   * Upgrade a license
-   */
-  async upgradeLicense(licenseId, features2) {
-    try {
-      const licenseServerUrl = this.getLicenseServerUrl();
-      const response = await fetchWithTimeout(`${licenseServerUrl}/api/licenses/${licenseId}/upgrade`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(features2)
-      });
-      const data = await response.json();
-      if (data.success) {
-        strapi2.log.info("[SUCCESS] License upgraded:", licenseId);
-        return data.data;
-      } else {
-        strapi2.log.error("[ERROR] License upgrade failed:", licenseId);
-        return null;
-      }
-    } catch (error) {
-      strapi2.log.error("[ERROR] Error upgrading license:", error);
-      return null;
+      strapi2.log.warn(
+        `[WARNING] License server unreachable during activation: ${error.message} (Key: ${licenseKey?.substring(0, 8)}...). Activation will not block this install.`
+      );
+      return { valid: false, data: null, networkError: true };
     }
   },
   /**
-   * Get license by key
+   * Look up a license by key on the upstream server. Used by the admin
+   * License page to display details. Network failures yield null.
+   *
+   * @param {string} licenseKey
+   * @returns {Promise<object|null>}
    */
   async getLicenseByKey(licenseKey) {
     try {
       const licenseServerUrl = this.getLicenseServerUrl();
       const response = await fetchWithTimeout(`${licenseServerUrl}/api/licenses/key/${licenseKey}`);
       const data = await response.json();
-      if (data.success) {
-        return data.data;
-      }
+      if (data.success) return data.data;
       return null;
     } catch (error) {
-      strapi2.log.error("[ERROR] Error fetching license by key:", error);
+      strapi2.log.warn("[WARNING] Could not fetch license by key:", error.message);
       return null;
     }
   },
   /**
-   * Get licenses by email
+   * Look up licenses by user email. Used by admin "auto-create" to
+   * decide whether to reuse an existing key.
+   *
+   * @param {string} email
+   * @returns {Promise<Array>}
    */
   async getLicensesByEmail(email2) {
     try {
       const licenseServerUrl = this.getLicenseServerUrl();
-      const response = await fetchWithTimeout(`${licenseServerUrl}/api/licenses/email/${encodeURIComponent(email2)}`);
+      const response = await fetchWithTimeout(
+        `${licenseServerUrl}/api/licenses/email/${encodeURIComponent(email2)}`
+      );
       const data = await response.json();
-      if (data.success) {
-        return data.data;
-      }
+      if (data.success) return data.data;
       return [];
     } catch (error) {
-      strapi2.log.error("[ERROR] Error fetching licenses by email:", error);
+      strapi2.log.warn("[WARNING] Could not fetch licenses by email:", error.message);
       return [];
     }
   },
+  // ======================================================================
+  // Storage (plugin store)
+  // ======================================================================
   /**
-   * Get online statistics
-   */
-  async getOnlineStats() {
-    try {
-      const licenseServerUrl = this.getLicenseServerUrl();
-      const response = await fetchWithTimeout(`${licenseServerUrl}/api/licenses/stats/online`);
-      const data = await response.json();
-      if (data.success) {
-        return data.data;
-      }
-      return null;
-    } catch (error) {
-      strapi2.log.error("[ERROR] Error fetching online stats:", error);
-      return null;
-    }
-  },
-  /**
-   * Start periodic pinging for a license
-   */
-  startPinging(licenseKey, intervalMinutes = 15) {
-    const intervalMs = intervalMinutes * 60 * 1e3;
-    this.pingLicense(licenseKey);
-    const pingInterval = setInterval(async () => {
-      await this.pingLicense(licenseKey);
-    }, intervalMs);
-    return pingInterval;
-  },
-  /**
-   * Initialize license guard
-   * Checks for existing license or prompts for creation
-   */
-  async initialize() {
-    try {
-      const pluginStore = strapi2.store({
-        type: "plugin",
-        name: "magic-link"
-      });
-      let licenseKey = await pluginStore.get({ key: "licenseKey" });
-      const lastValidated = await pluginStore.get({ key: "lastValidated" });
-      const now = /* @__PURE__ */ new Date();
-      const gracePeriodHours = 24;
-      let withinGracePeriod = false;
-      if (lastValidated) {
-        const lastValidatedDate = new Date(lastValidated);
-        const hoursSinceValidation = (now - lastValidatedDate) / (1e3 * 60 * 60);
-        withinGracePeriod = hoursSinceValidation < gracePeriodHours;
-      }
-      if (licenseKey) {
-        const verification = await this.verifyLicense(licenseKey, true);
-        if (verification.valid) {
-          const pingInterval = this.startPinging(licenseKey, 15);
-          strapi2.licenseGuard = {
-            licenseKey,
-            pingInterval,
-            data: verification.data
-          };
-          return { valid: true, data: verification.data };
-        } else {
-          strapi2.log.warn("[WARNING] Stored license is invalid or expired");
-          if (!withinGracePeriod) {
-            await pluginStore.delete({ key: "licenseKey" });
-            await pluginStore.delete({ key: "lastValidated" });
-          }
-        }
-      }
-      strapi2.log.warn("[WARNING] No valid license found. Plugin will run in demo mode.");
-      return { valid: false, demo: true };
-    } catch (error) {
-      strapi2.log.error("[ERROR] Error initializing license guard:", error);
-      return { valid: false, error: error.message };
-    }
-  },
-  /**
-   * Store license key after creation
+   * Persist a license key to the plugin store. Used by the admin
+   * activation form.
+   *
+   * @param {string} licenseKey
+   * @returns {Promise<boolean>}
    */
   async storeLicenseKey(licenseKey) {
     try {
-      strapi2.log.info(`[LICENSE] Storing license key: ${licenseKey?.substring(0, 8)}...`);
-      const pluginStore = strapi2.store({
-        type: "plugin",
-        name: "magic-link"
-      });
+      const pluginStore = strapi2.store({ type: "plugin", name: "magic-link" });
       await pluginStore.set({ key: "licenseKey", value: licenseKey });
       await pluginStore.set({ key: "lastValidated", value: (/* @__PURE__ */ new Date()).toISOString() });
-      const stored = await pluginStore.get({ key: "licenseKey" });
-      if (stored === licenseKey) {
-        strapi2.log.info("[SUCCESS] License key stored and verified successfully");
-        return true;
-      } else {
-        strapi2.log.error("[ERROR] License key storage verification failed");
-        return false;
-      }
+      strapi2.log.info("[SUCCESS] License key stored");
+      return true;
     } catch (error) {
-      strapi2.log.error("[ERROR] Error storing license key:", error);
+      strapi2.log.error("[ERROR] Error storing license key:", error.message);
       return false;
     }
   },
+  // ======================================================================
+  // Lifecycle (no-ops in the marketplace build)
+  // ======================================================================
+  /**
+   * Boot-time initializer. In the marketplace build this is a no-op:
+   * we do not auto-verify the stored key and we do not start a periodic
+   * ping. Kept as a stable export so bootstrap.js continues to work.
+   *
+   * @returns {Promise<{valid: boolean}>}
+   */
+  async initialize() {
+    return { valid: true };
+  },
   /**
-   * Cleanup on plugin destroy
+   * Plugin destroy hook. No-op (no interval to clear in the marketplace
+   * build).
    */
   cleanup() {
-    if (strapi2.licenseGuard && strapi2.licenseGuard.pingInterval) {
-      clearInterval(strapi2.licenseGuard.pingInterval);
-      strapi2.log.info("[INFO] License pinging stopped");
-    }
   },
+  // ======================================================================
+  // Permissive feature stubs (kept for backward compatibility with any
+  // legacy caller — they always permit, never gate)
+  // ======================================================================
   /**
-   * Check if a feature is available
-   * @param {string} featureName - Feature name to check
-   * @returns {boolean}
+   * Always-permissive feature check. Kept so any legacy `if (await
+   * licenseGuard.hasFeature(...))` site continues to compile and runs
+   * the gated branch.
+   *
+   * @returns {Promise<boolean>} always true
    */
-  async hasFeature(featureName) {
-    try {
-      const pluginStore = strapi2.store({ type: "plugin", name: "magic-link" });
-      const licenseKey = await pluginStore.get({ key: "licenseKey" });
-      if (!licenseKey) {
-        return features.hasFeature(null, featureName);
-      }
-      const licenseData = await this.getLicenseByKey(licenseKey);
-      return features.hasFeature(licenseData, featureName);
-    } catch (error) {
-      strapi2.log.error("Error checking feature:", error);
-      return false;
-    }
+  // eslint-disable-next-line no-unused-vars
+  async hasFeature(_featureName) {
+    return true;
   },
   /**
-   * Get max allowed tokens
-   * @returns {number} Max tokens (-1 = unlimited)
+   * @returns {Promise<number>} -1 (unlimited)
    */
   async getMaxTokens() {
-    try {
-      const pluginStore = strapi2.store({ type: "plugin", name: "magic-link" });
-      const licenseKey = await pluginStore.get({ key: "licenseKey" });
-      if (!licenseKey) {
-        return features.getMaxTokens(null);
-      }
-      const licenseData = await this.getLicenseByKey(licenseKey);
-      return features.getMaxTokens(licenseData);
-    } catch (error) {
-      strapi2.log.error("Error getting max tokens:", error);
-      return features.free.maxTokens;
-    }
+    return -1;
   },
   /**
-   * Get max allowed sessions
-   * @returns {number} Max sessions (-1 = unlimited)
+   * @returns {Promise<number>} -1 (unlimited)
    */
   async getMaxSessions() {
-    try {
-      const pluginStore = strapi2.store({ type: "plugin", name: "magic-link" });
-      const licenseKey = await pluginStore.get({ key: "licenseKey" });
-      if (!licenseKey) {
-        return features.getMaxSessions(null);
-      }
-      const licenseData = await this.getLicenseByKey(licenseKey);
-      return features.getMaxSessions(licenseData);
-    } catch (error) {
-      strapi2.log.error("Error getting max sessions:", error);
-      return features.free.maxSessions;
-    }
+    return -1;
   },
   /**
-   * Get max allowed IP bans
-   * @returns {number} Max IP bans (-1 = unlimited)
+   * @returns {Promise<number>} -1 (unlimited)
    */
   async getMaxIPBans() {
-    try {
-      const pluginStore = strapi2.store({ type: "plugin", name: "magic-link" });
-      const licenseKey = await pluginStore.get({ key: "licenseKey" });
-      if (!licenseKey) {
-        return features.getMaxIPBans(null);
-      }
-      const licenseData = await this.getLicenseByKey(licenseKey);
-      return features.getMaxIPBans(licenseData);
-    } catch (error) {
-      strapi2.log.error("Error getting max IP bans:", error);
-      return features.free.maxIPBans;
-    }
+    return -1;
   },
   /**
-   * Get available OTP types
-   * @returns {Array} Available OTP types
+   * @returns {Promise<string[]>} every supported OTP type
    */
   async getAvailableOTPTypes() {
-    try {
-      const pluginStore = strapi2.store({ type: "plugin", name: "magic-link" });
-      const licenseKey = await pluginStore.get({ key: "licenseKey" });
-      if (!licenseKey) {
-        return features.getAvailableOTPTypes(null);
-      }
-      const licenseData = await this.getLicenseByKey(licenseKey);
-      return features.getAvailableOTPTypes(licenseData);
-    } catch (error) {
-      strapi2.log.error("Error getting available OTP types:", error);
-      return [];
-    }
+    return ["email", "totp", "backup-codes"];
   },
   /**
-   * Get license tier info
-   * @returns {Object} License tier information
+   * Tier info for UI display. Reports `pro` when a key is stored,
+   * `free` otherwise. Pure information — no behavior depends on this.
+   *
+   * @returns {Promise<{tier: string, features: object, hasKey: boolean}>}
    */
   async getLicenseTierInfo() {
     try {
       const pluginStore = strapi2.store({ type: "plugin", name: "magic-link" });
       const licenseKey = await pluginStore.get({ key: "licenseKey" });
-      if (!licenseKey) {
-        return {
-          tier: "free",
-          features: {
-            premium: false,
-            advanced: false,
-            enterprise: false
-          }
-        };
-      }
-      const licenseData = await this.getLicenseByKey(licenseKey);
+      const hasKey = !!licenseKey;
       return {
-        tier: licenseData?.tier || "free",
+        tier: hasKey ? "pro" : "free",
+        hasKey,
         features: {
-          premium: licenseData?.featurePremium || licenseData?.features?.premium || false,
-          advanced: licenseData?.featureAdvanced || licenseData?.features?.advanced || false,
-          enterprise: licenseData?.featureEnterprise || licenseData?.features?.enterprise || false
+          premium: hasKey,
+          advanced: hasKey,
+          enterprise: hasKey
         }
       };
     } catch (error) {
-      strapi2.log.error("Error getting license tier info:", error);
       return {
         tier: "free",
-        features: {
-          premium: false,
-          advanced: false,
-          enterprise: false
-        }
+        hasKey: false,
+        features: { premium: false, advanced: false, enterprise: false }
       };
     }
   }