strapi-plugin-magic-mark 3.1.0 → 3.2.1

package/dist/server/index.mjs

@@ -2,6 +2,65 @@ import crypto from "crypto";
 import os from "os";
 import { readFileSync } from "fs";
 import { join } from "path";
+const PLUGIN_NAME = "magic-mark";
+const PREFIX = "[Magic-Mark]";
+function formatMessage(prefix, args) {
+  if (args.length === 0) return prefix;
+  const parts = args.map(
+    (arg) => typeof arg === "string" ? arg : JSON.stringify(arg)
+  );
+  return `${prefix} ${parts.join(" ")}`;
+}
+function createLogger(strapi) {
+  const getDebugMode = () => {
+    try {
+      const config2 = strapi.config.get(`plugin::${PLUGIN_NAME}`) || {};
+      return config2.debug === true;
+    } catch {
+      return false;
+    }
+  };
+  return {
+    /**
+     * Log info - only when debug: true
+     */
+    info: (...args) => {
+      if (getDebugMode()) {
+        strapi.log.info(formatMessage(PREFIX, args));
+      }
+    },
+    /**
+     * Log debug - only when debug: true
+     */
+    debug: (...args) => {
+      if (getDebugMode()) {
+        strapi.log.debug(formatMessage(PREFIX, args));
+      }
+    },
+    /**
+     * Log warning - only when debug: true
+     */
+    warn: (...args) => {
+      if (getDebugMode()) {
+        strapi.log.warn(formatMessage(PREFIX, args));
+      }
+    },
+    /**
+     * Log error - only when debug: true
+     */
+    error: (...args) => {
+      if (getDebugMode()) {
+        strapi.log.error(formatMessage(PREFIX, args));
+      }
+    },
+    /**
+     * Force log - always logged (for critical errors only)
+     */
+    forceError: (...args) => {
+      strapi.log.error(formatMessage(PREFIX, args));
+    }
+  };
+}
 const magicMarkActions = {
   actions: [
     {
@@ -21,68 +80,74 @@ const magicMarkActions = {
   ]
 };
 const register = async ({ strapi }) => {
+  const log = createLogger(strapi);
   await strapi.admin.services.permission.actionProvider.registerMany(
     magicMarkActions.actions
   );
-  strapi.log.info("[Magic-Mark] Plugin registered successfully");
+  log.info("Plugin registered successfully");
 };
 const bootstrap = ({ strapi }) => {
-  strapi.log.info("[Magic-Mark] Plugin bootstrapping...");
+  const log = createLogger(strapi);
+  log.info("Plugin bootstrapping...");
   try {
     const licenseGuardService2 = strapi.plugin("magic-mark").service("license-guard");
     setTimeout(async () => {
       const licenseStatus = await licenseGuardService2.initialize();
       if (!licenseStatus.valid) {
-        strapi.log.error("╔════════════════════════════════════════════════════════════════╗");
-        strapi.log.error("║  [ERROR] MAGICMARK PLUGIN - NO VALID LICENSE                  ║");
-        strapi.log.error("║                                                                ║");
-        strapi.log.error("║  This plugin requires a valid license to operate.             ║");
-        strapi.log.error("║  Please activate your license via Admin UI:                   ║");
-        strapi.log.error("║  Go to Settings → MagicMark → License                         ║");
-        strapi.log.error("║                                                                ║");
-        strapi.log.error("║  The plugin will run with limited functionality until         ║");
-        strapi.log.error("║  a valid license is activated.                                ║");
-        strapi.log.error("╚════════════════════════════════════════════════════════════════╝");
+        log.error("╔════════════════════════════════════════════════════════════════╗");
+        log.error("║  [ERROR] MAGICMARK PLUGIN - NO VALID LICENSE                  ║");
+        log.error("║                                                                ║");
+        log.error("║  This plugin requires a valid license to operate.             ║");
+        log.error("║  Please activate your license via Admin UI:                   ║");
+        log.error("║  Go to Settings → MagicMark → License                         ║");
+        log.error("║                                                                ║");
+        log.error("║  The plugin will run with limited functionality until         ║");
+        log.error("║  a valid license is activated.                                ║");
+        log.error("╚════════════════════════════════════════════════════════════════╝");
       } else if (licenseStatus.valid) {
         const pluginStore = strapi.store({
           type: "plugin",
           name: "magic-mark"
         });
         const storedKey = await pluginStore.get({ key: "licenseKey" });
-        strapi.log.info("╔════════════════════════════════════════════════════════════════╗");
-        strapi.log.info("║  [SUCCESS] MAGICMARK PLUGIN LICENSE ACTIVE                    ║");
-        strapi.log.info("║                                                                ║");
+        log.info("╔════════════════════════════════════════════════════════════════╗");
+        log.info("║  [SUCCESS] MAGICMARK PLUGIN LICENSE ACTIVE                    ║");
+        log.info("║                                                                ║");
         if (licenseStatus.data) {
-          strapi.log.info(`║  License: ${licenseStatus.data.licenseKey}                    ║`);
-          strapi.log.info(`║  User: ${licenseStatus.data.firstName} ${licenseStatus.data.lastName}`.padEnd(66) + "║");
-          strapi.log.info(`║  Email: ${licenseStatus.data.email}`.padEnd(66) + "║");
+          log.info(`║  License: ${licenseStatus.data.licenseKey}                    ║`);
+          log.info(`║  User: ${licenseStatus.data.firstName} ${licenseStatus.data.lastName}`.padEnd(66) + "║");
+          log.info(`║  Email: ${licenseStatus.data.email}`.padEnd(66) + "║");
         } else if (storedKey) {
-          strapi.log.info(`║  License: ${storedKey} (Offline Mode)                         ║`);
-          strapi.log.info(`║  Status: Grace Period Active                                  ║`);
+          log.info(`║  License: ${storedKey} (Offline Mode)                         ║`);
+          log.info(`║  Status: Grace Period Active                                  ║`);
         }
-        strapi.log.info("║                                                                ║");
-        strapi.log.info("║  [PING] Auto-pinging every 15 minutes                         ║");
-        strapi.log.info("╚════════════════════════════════════════════════════════════════╝");
+        log.info("║                                                                ║");
+        log.info("║  [PING] Auto-pinging every 15 minutes                         ║");
+        log.info("╚════════════════════════════════════════════════════════════════╝");
       }
     }, 3e3);
   } catch (error) {
-    strapi.log.error("[ERROR] Error initializing License Guard:", error);
+    log.error("[ERROR] Error initializing License Guard:", error);
   }
-  strapi.log.info("[Magic-Mark] Plugin bootstrapped successfully");
+  log.info("Plugin bootstrapped successfully");
 };
 const destroy = ({ strapi }) => {
+  const log = createLogger(strapi);
   try {
     const licenseGuardService2 = strapi.plugin("magic-mark")?.service("license-guard");
     if (licenseGuardService2) {
       licenseGuardService2.cleanup();
-      strapi.log.info("[SUCCESS] License Guard cleanup completed");
+      log.info("[SUCCESS] License Guard cleanup completed");
     }
   } catch (error) {
-    strapi.log.error("[ERROR] Error during License Guard cleanup:", error);
+    log.error("[ERROR] Error during License Guard cleanup:", error);
   }
 };
 const config = {
-  default: {},
+  default: {
+    // Enable debug logging (set to true to see all plugin logs)
+    debug: false
+  },
   validator: () => {
   }
 };
@@ -1069,507 +1134,510 @@ try {
 } catch (e) {
 }
 const LICENSE_SERVER_URL = "https://magicapi.fitlex.me";
-const licenseGuardService = ({ strapi }) => ({
-  /**
-   * Get license server URL (hardcoded and immutable for security)
-   * @returns The fixed license server URL - cannot be overridden
-   */
-  getLicenseServerUrl() {
-    return LICENSE_SERVER_URL;
-  },
-  /**
-   * Generate a unique device ID based on machine identifiers
-   */
-  generateDeviceId() {
-    try {
-      const networkInterfaces = os.networkInterfaces();
-      const macAddresses = [];
-      Object.values(networkInterfaces).forEach((interfaces) => {
-        interfaces?.forEach((iface) => {
-          if (iface.mac && iface.mac !== "00:00:00:00:00:00") {
-            macAddresses.push(iface.mac);
-          }
+const licenseGuardService = ({ strapi }) => {
+  const log = createLogger(strapi);
+  return {
+    /**
+     * Get license server URL (hardcoded and immutable for security)
+     * @returns The fixed license server URL - cannot be overridden
+     */
+    getLicenseServerUrl() {
+      return LICENSE_SERVER_URL;
+    },
+    /**
+     * Generate a unique device ID based on machine identifiers
+     */
+    generateDeviceId() {
+      try {
+        const networkInterfaces = os.networkInterfaces();
+        const macAddresses = [];
+        Object.values(networkInterfaces).forEach((interfaces) => {
+          interfaces?.forEach((iface) => {
+            if (iface.mac && iface.mac !== "00:00:00:00:00:00") {
+              macAddresses.push(iface.mac);
+            }
+          });
         });
-      });
-      const identifier = `${macAddresses.join("-")}-${os.hostname()}`;
-      return crypto.createHash("sha256").update(identifier).digest("hex").substring(0, 32);
-    } catch (error) {
-      strapi.log.error("Error generating device ID:", error);
-      return crypto.randomBytes(16).toString("hex");
-    }
-  },
-  /**
-   * Get device name
-   */
-  getDeviceName() {
-    try {
-      return os.hostname() || "Unknown Device";
-    } catch (error) {
-      return "Unknown Device";
-    }
-  },
-  /**
-   * Get server IP address
-   */
-  getIpAddress() {
-    try {
-      const networkInterfaces = os.networkInterfaces();
-      for (const name of Object.keys(networkInterfaces)) {
-        const interfaces = networkInterfaces[name];
-        if (interfaces) {
-          for (const iface of interfaces) {
-            if (iface.family === "IPv4" && !iface.internal) {
-              return iface.address;
+        const identifier = `${macAddresses.join("-")}-${os.hostname()}`;
+        return crypto.createHash("sha256").update(identifier).digest("hex").substring(0, 32);
+      } catch (error) {
+        log.error("Error generating device ID:", error);
+        return crypto.randomBytes(16).toString("hex");
+      }
+    },
+    /**
+     * Get device name
+     */
+    getDeviceName() {
+      try {
+        return os.hostname() || "Unknown Device";
+      } catch (error) {
+        return "Unknown Device";
+      }
+    },
+    /**
+     * Get server IP address
+     */
+    getIpAddress() {
+      try {
+        const networkInterfaces = os.networkInterfaces();
+        for (const name of Object.keys(networkInterfaces)) {
+          const interfaces = networkInterfaces[name];
+          if (interfaces) {
+            for (const iface of interfaces) {
+              if (iface.family === "IPv4" && !iface.internal) {
+                return iface.address;
+              }
             }
           }
         }
+        return "127.0.0.1";
+      } catch (error) {
+        return "127.0.0.1";
       }
-      return "127.0.0.1";
-    } catch (error) {
-      return "127.0.0.1";
-    }
-  },
-  /**
-   * Get user agent (server context)
-   */
-  getUserAgent() {
-    const strapiVersion = strapi.config.get("info.strapi") || "5.0.0";
-    return `MagicMark/${pluginVersion} Strapi/${strapiVersion} Node/${process.version} ${os.platform()}/${os.release()}`;
-  },
-  /**
-   * Create a license
-   */
-  async createLicense({ email, firstName, lastName }) {
-    try {
-      const deviceId = this.generateDeviceId();
-      const deviceName = this.getDeviceName();
-      const ipAddress = this.getIpAddress();
-      const userAgent = this.getUserAgent();
-      const licenseServerUrl = this.getLicenseServerUrl();
-      const response = await fetch(`${licenseServerUrl}/api/licenses/create`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          email,
-          firstName,
-          lastName,
-          deviceName,
-          deviceId,
-          ipAddress,
-          userAgent,
-          pluginName: "magic-mark",
-          productName: "MagicMark - Advanced Query Builder"
-        })
-      });
-      const data = await response.json();
-      if (data.success) {
-        strapi.log.info("[SUCCESS] License created successfully:", data.data.licenseKey);
-        return data.data;
-      } else {
-        strapi.log.error("[ERROR] License creation failed:", data);
+    },
+    /**
+     * Get user agent (server context)
+     */
+    getUserAgent() {
+      const strapiVersion = strapi.config.get("info.strapi") || "5.0.0";
+      return `MagicMark/${pluginVersion} Strapi/${strapiVersion} Node/${process.version} ${os.platform()}/${os.release()}`;
+    },
+    /**
+     * Create a license
+     */
+    async createLicense({ email, firstName, lastName }) {
+      try {
+        const deviceId = this.generateDeviceId();
+        const deviceName = this.getDeviceName();
+        const ipAddress = this.getIpAddress();
+        const userAgent = this.getUserAgent();
+        const licenseServerUrl = this.getLicenseServerUrl();
+        const response = await fetch(`${licenseServerUrl}/api/licenses/create`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            email,
+            firstName,
+            lastName,
+            deviceName,
+            deviceId,
+            ipAddress,
+            userAgent,
+            pluginName: "magic-mark",
+            productName: "MagicMark - Advanced Query Builder"
+          })
+        });
+        const data = await response.json();
+        if (data.success) {
+          log.info("[SUCCESS] License created successfully:", data.data.licenseKey);
+          return data.data;
+        } else {
+          log.error("[ERROR] License creation failed:", data);
+          return null;
+        }
+      } catch (error) {
+        log.error("[ERROR] Error creating license:", error);
         return null;
       }
-    } catch (error) {
-      strapi.log.error("[ERROR] Error creating license:", error);
-      return null;
-    }
-  },
-  /**
-   * Verify a license (with grace period support)
-   */
-  async verifyLicense(licenseKey, allowGracePeriod = false) {
-    try {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 5e3);
-      const licenseServerUrl = this.getLicenseServerUrl();
-      const response = await fetch(`${licenseServerUrl}/api/licenses/verify`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          licenseKey,
-          pluginName: "magic-mark",
-          productName: "MagicMark - Advanced Query Builder"
-        }),
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      const data = await response.json();
-      if (data.success) {
-        const isValid = data.data.isActive && !data.data.isExpired;
-        const statusInfo = data.data.isExpired ? "EXPIRED" : data.data.isActive ? "ACTIVE" : "INACTIVE";
-        strapi.log.info(`[SUCCESS] License verified online: ${statusInfo} (Key: ${licenseKey?.substring(0, 8)}...)`);
-        if (isValid) {
-          const pluginStore = strapi.store({
-            type: "plugin",
-            name: "magic-mark"
-          });
-          await pluginStore.set({ key: "lastValidated", value: (/* @__PURE__ */ new Date()).toISOString() });
+    },
+    /**
+     * Verify a license (with grace period support)
+     */
+    async verifyLicense(licenseKey, allowGracePeriod = false) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 5e3);
+        const licenseServerUrl = this.getLicenseServerUrl();
+        const response = await fetch(`${licenseServerUrl}/api/licenses/verify`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            licenseKey,
+            pluginName: "magic-mark",
+            productName: "MagicMark - Advanced Query Builder"
+          }),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        const data = await response.json();
+        if (data.success) {
+          const isValid = data.data.isActive && !data.data.isExpired;
+          const statusInfo = data.data.isExpired ? "EXPIRED" : data.data.isActive ? "ACTIVE" : "INACTIVE";
+          log.info(`[SUCCESS] License verified online: ${statusInfo} (Key: ${licenseKey?.substring(0, 8)}...)`);
+          if (isValid) {
+            const pluginStore = strapi.store({
+              type: "plugin",
+              name: "magic-mark"
+            });
+            await pluginStore.set({ key: "lastValidated", value: (/* @__PURE__ */ new Date()).toISOString() });
+          }
+          return {
+            valid: isValid,
+            data: data.data
+          };
+        } else {
+          log.warn(`[WARN] License verification failed: ${data.message || "Unknown error"} (Key: ${licenseKey?.substring(0, 8)}...)`);
+          return { valid: false, data: null };
         }
-        return {
-          valid: isValid,
-          data: data.data
-        };
-      } else {
-        strapi.log.warn(`[WARN] License verification failed: ${data.message || "Unknown error"} (Key: ${licenseKey?.substring(0, 8)}...)`);
+      } catch (error) {
+        if (allowGracePeriod) {
+          log.warn(`[WARN] Cannot verify license online: ${error.message} (Key: ${licenseKey?.substring(0, 8)}...)`);
+          log.info(`[GRACE] Grace period active - accepting stored license key`);
+          return { valid: true, data: null, gracePeriod: true };
+        }
+        log.error(`[ERROR] Error verifying license: ${error.message} (Key: ${licenseKey?.substring(0, 8)}...)`);
         return { valid: false, data: null };
       }
-    } catch (error) {
-      if (allowGracePeriod) {
-        strapi.log.warn(`[WARN] Cannot verify license online: ${error.message} (Key: ${licenseKey?.substring(0, 8)}...)`);
-        strapi.log.info(`[GRACE] Grace period active - accepting stored license key`);
-        return { valid: true, data: null, gracePeriod: true };
-      }
-      strapi.log.error(`[ERROR] Error verifying license: ${error.message} (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 fetch(`${licenseServerUrl}/api/licenses/ping`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          licenseKey,
-          pluginName: "magic-mark",
-          productName: "MagicMark - Advanced Query Builder"
-        })
-      });
-      const data = await response.json();
-      if (data.success) {
-        strapi.log.debug(`[PING] License ping successful: ${data.data?.isActive ? "ACTIVE" : "INACTIVE"} (Key: ${licenseKey?.substring(0, 8)}...)`);
-        return data.data;
-      } else {
-        strapi.log.debug(`[WARN] License ping failed: ${data.message || "Unknown error"} (Key: ${licenseKey?.substring(0, 8)}...)`);
+    },
+    /**
+     * Ping a license (lightweight check)
+     */
+    async pingLicense(licenseKey) {
+      try {
+        const licenseServerUrl = this.getLicenseServerUrl();
+        const response = await fetch(`${licenseServerUrl}/api/licenses/ping`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            licenseKey,
+            pluginName: "magic-mark",
+            productName: "MagicMark - Advanced Query Builder"
+          })
+        });
+        const data = await response.json();
+        if (data.success) {
+          log.debug(`[PING] License ping successful: ${data.data?.isActive ? "ACTIVE" : "INACTIVE"} (Key: ${licenseKey?.substring(0, 8)}...)`);
+          return data.data;
+        } else {
+          log.debug(`[WARN] License ping failed: ${data.message || "Unknown error"} (Key: ${licenseKey?.substring(0, 8)}...)`);
+          return null;
+        }
+      } catch (error) {
+        log.debug(`License ping error: ${error.message} (Key: ${licenseKey?.substring(0, 8)}...)`);
         return null;
       }
-    } catch (error) {
-      strapi.log.debug(`License ping error: ${error.message} (Key: ${licenseKey?.substring(0, 8)}...)`);
-      return null;
-    }
-  },
-  /**
-   * Get license by key
-   */
-  async getLicenseByKey(licenseKey) {
-    try {
-      const licenseServerUrl = this.getLicenseServerUrl();
-      const response = await fetch(`${licenseServerUrl}/api/licenses/key/${licenseKey}`);
-      const data = await response.json();
-      if (data.success) {
-        return data.data;
+    },
+    /**
+     * Get license by key
+     */
+    async getLicenseByKey(licenseKey) {
+      try {
+        const licenseServerUrl = this.getLicenseServerUrl();
+        const response = await fetch(`${licenseServerUrl}/api/licenses/key/${licenseKey}`);
+        const data = await response.json();
+        if (data.success) {
+          return data.data;
+        }
+        return null;
+      } catch (error) {
+        log.error("[ERROR] Error fetching license by key:", error);
+        return null;
       }
-      return null;
-    } catch (error) {
-      strapi.log.error("[ERROR] Error fetching license by key:", error);
-      return null;
-    }
-  },
-  /**
-   * Get current license data from store (fetches fresh from server)
-   * This is the correct way to get license data with all feature flags
-   */
-  async getCurrentLicense() {
-    try {
-      const pluginStore = strapi.store({
-        type: "plugin",
-        name: "magic-mark"
-      });
-      const licenseKey = await pluginStore.get({ key: "licenseKey" });
-      if (!licenseKey) {
+    },
+    /**
+     * Get current license data from store (fetches fresh from server)
+     * This is the correct way to get license data with all feature flags
+     */
+    async getCurrentLicense() {
+      try {
+        const pluginStore = strapi.store({
+          type: "plugin",
+          name: "magic-mark"
+        });
+        const licenseKey = await pluginStore.get({ key: "licenseKey" });
+        if (!licenseKey) {
+          return null;
+        }
+        const license2 = await this.getLicenseByKey(licenseKey);
+        return license2;
+      } catch (error) {
+        log.error("[LICENSE] Error loading current license:", error);
         return null;
       }
-      const license2 = await this.getLicenseByKey(licenseKey);
-      return license2;
-    } catch (error) {
-      strapi.log.error("[LICENSE] Error loading current license:", 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);
-    strapi.log.info(`[PING] Started pinging license every ${intervalMinutes} minutes`);
-    return pingInterval;
-  },
-  /**
-   * Initialize license guard
-   * Checks for existing license or prompts for creation
-   */
-  async initialize() {
-    try {
-      strapi.log.info("[LICENSE] Initializing License Guard...");
-      const pluginStore = strapi.store({
-        type: "plugin",
-        name: "magic-mark"
-      });
-      const 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.getTime() - lastValidatedDate.getTime()) / (1e3 * 60 * 60);
-        withinGracePeriod = hoursSinceValidation < gracePeriodHours;
-      }
-      strapi.log.info("──────────────────────────────────────────────────────────");
-      strapi.log.info(`[STORE] Plugin Store Check:`);
-      if (licenseKey) {
-        strapi.log.info(`   [OK] License Key found: ${licenseKey}`);
-        strapi.log.info(`   [KEY] Key (short): ${licenseKey.substring(0, 8)}...`);
+    },
+    /**
+     * 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);
+      log.info(`[PING] Started pinging license every ${intervalMinutes} minutes`);
+      return pingInterval;
+    },
+    /**
+     * Initialize license guard
+     * Checks for existing license or prompts for creation
+     */
+    async initialize() {
+      try {
+        log.info("[LICENSE] Initializing License Guard...");
+        const pluginStore = strapi.store({
+          type: "plugin",
+          name: "magic-mark"
+        });
+        const 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 hoursAgo = Math.floor((now.getTime() - lastValidatedDate.getTime()) / (1e3 * 60 * 60));
-          strapi.log.info(`   [TIME] Last validated: ${hoursAgo}h ago (Grace: ${withinGracePeriod ? "ACTIVE" : "EXPIRED"})`);
-        } else {
-          strapi.log.info(`   [TIME] Last validated: Never (Grace: ACTIVE for first ${gracePeriodHours}h)`);
+          const hoursSinceValidation = (now.getTime() - lastValidatedDate.getTime()) / (1e3 * 60 * 60);
+          withinGracePeriod = hoursSinceValidation < gracePeriodHours;
         }
-      } else {
-        strapi.log.info(`   [NONE] No license key stored`);
-      }
-      strapi.log.info("──────────────────────────────────────────────────────────");
-      if (licenseKey) {
-        strapi.log.info("[VERIFY] Verifying stored license key...");
-        const verification = await this.verifyLicense(licenseKey, true);
-        if (verification.valid) {
-          if (verification.gracePeriod) {
-            strapi.log.info("[SUCCESS] License accepted (offline mode / grace period)");
+        log.info("──────────────────────────────────────────────────────────");
+        log.info(`[STORE] Plugin Store Check:`);
+        if (licenseKey) {
+          log.info(`   [OK] License Key found: ${licenseKey}`);
+          log.info(`   [KEY] Key (short): ${licenseKey.substring(0, 8)}...`);
+          if (lastValidated) {
+            const lastValidatedDate = new Date(lastValidated);
+            const hoursAgo = Math.floor((now.getTime() - lastValidatedDate.getTime()) / (1e3 * 60 * 60));
+            log.info(`   [TIME] Last validated: ${hoursAgo}h ago (Grace: ${withinGracePeriod ? "ACTIVE" : "EXPIRED"})`);
           } else {
-            strapi.log.info("[SUCCESS] License is valid and active");
+            log.info(`   [TIME] Last validated: Never (Grace: ACTIVE for first ${gracePeriodHours}h)`);
           }
-          const pingInterval = this.startPinging(licenseKey, 15);
-          strapi.licenseGuard = {
-            licenseKey,
-            pingInterval,
-            data: verification.data
-          };
-          return { valid: true, data: verification.data };
         } else {
-          strapi.log.warn("[WARN] Stored license is invalid or expired");
-          if (!withinGracePeriod) {
-            await pluginStore.delete({ key: "licenseKey" });
-            await pluginStore.delete({ key: "lastValidated" });
+          log.info(`   [NONE] No license key stored`);
+        }
+        log.info("──────────────────────────────────────────────────────────");
+        if (licenseKey) {
+          log.info("[VERIFY] Verifying stored license key...");
+          const verification = await this.verifyLicense(licenseKey, true);
+          if (verification.valid) {
+            if (verification.gracePeriod) {
+              log.info("[SUCCESS] License accepted (offline mode / grace period)");
+            } else {
+              log.info("[SUCCESS] License is valid and active");
+            }
+            const pingInterval = this.startPinging(licenseKey, 15);
+            strapi.licenseGuard = {
+              licenseKey,
+              pingInterval,
+              data: verification.data
+            };
+            return { valid: true, data: verification.data };
+          } else {
+            log.warn("[WARN] Stored license is invalid or expired");
+            if (!withinGracePeriod) {
+              await pluginStore.delete({ key: "licenseKey" });
+              await pluginStore.delete({ key: "lastValidated" });
+            }
           }
         }
+        log.warn("[WARN] No valid license found. Plugin will run with limited functionality.");
+        return { valid: false, demo: true };
+      } catch (error) {
+        log.error("[ERROR] Error initializing license guard:", error);
+        return { valid: false, error: error.message };
       }
-      strapi.log.warn("[WARN] No valid license found. Plugin will run with limited functionality.");
-      return { valid: false, demo: true };
-    } catch (error) {
-      strapi.log.error("[ERROR] Error initializing license guard:", error);
-      return { valid: false, error: error.message };
-    }
-  },
-  /**
-   * Store license key after creation
-   */
-  async storeLicenseKey(licenseKey) {
-    try {
-      strapi.log.info(`[STORE] Storing license key: ${licenseKey}`);
-      const pluginStore = strapi.store({
-        type: "plugin",
-        name: "magic-mark"
-      });
-      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) {
-        strapi.log.info("[SUCCESS] License key stored and verified successfully");
-        return true;
-      } else {
-        strapi.log.error("[ERROR] License key storage verification failed");
+    },
+    /**
+     * Store license key after creation
+     */
+    async storeLicenseKey(licenseKey) {
+      try {
+        log.info(`[STORE] Storing license key: ${licenseKey}`);
+        const pluginStore = strapi.store({
+          type: "plugin",
+          name: "magic-mark"
+        });
+        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) {
+          log.info("[SUCCESS] License key stored and verified successfully");
+          return true;
+        } else {
+          log.error("[ERROR] License key storage verification failed");
+          return false;
+        }
+      } catch (error) {
+        log.error("[ERROR] Error storing license key:", error);
         return false;
       }
-    } catch (error) {
-      strapi.log.error("[ERROR] Error storing license key:", error);
-      return false;
-    }
-  },
-  /**
-   * Get bookmark limit based on license tier
-   * @returns Bookmark limit: 10 (free), 50 (premium), -1 (advanced/unlimited)
-   */
-  async getBookmarkLimit() {
-    try {
-      const licenseGuard = strapi.licenseGuard;
-      const licenseData = licenseGuard?.data;
-      if (licenseData?.featureAdvanced) {
-        return -1;
-      }
-      if (licenseData?.featurePremium) {
-        return 50;
+    },
+    /**
+     * Get bookmark limit based on license tier
+     * @returns Bookmark limit: 10 (free), 50 (premium), -1 (advanced/unlimited)
+     */
+    async getBookmarkLimit() {
+      try {
+        const licenseGuard = strapi.licenseGuard;
+        const licenseData = licenseGuard?.data;
+        if (licenseData?.featureAdvanced) {
+          return -1;
+        }
+        if (licenseData?.featurePremium) {
+          return 50;
+        }
+        return 10;
+      } catch (error) {
+        log.debug("[LICENSE] Error getting bookmark limit, using free tier");
+        return 10;
       }
-      return 10;
-    } catch (error) {
-      strapi.log.debug("[LICENSE] Error getting bookmark limit, using free tier");
-      return 10;
-    }
-  },
-  /**
-   * Check if user can create more bookmarks
-   * @param userId - User's documentId
-   * @returns Object with canCreate boolean and current/max counts
-   */
-  async canCreateBookmark(userId) {
-    try {
-      const limit = await this.getBookmarkLimit();
-      if (limit === -1) {
-        return { canCreate: true, current: 0, max: -1 };
+    },
+    /**
+     * Check if user can create more bookmarks
+     * @param userId - User's documentId
+     * @returns Object with canCreate boolean and current/max counts
+     */
+    async canCreateBookmark(userId) {
+      try {
+        const limit = await this.getBookmarkLimit();
+        if (limit === -1) {
+          return { canCreate: true, current: 0, max: -1 };
+        }
+        const BOOKMARK_UID2 = "plugin::magic-mark.bookmark";
+        const bookmarks = await strapi.documents(BOOKMARK_UID2).findMany({
+          filters: { creatorId: userId }
+        });
+        const currentCount = bookmarks?.length || 0;
+        if (currentCount >= limit) {
+          return {
+            canCreate: false,
+            current: currentCount,
+            max: limit,
+            message: `Bookmark limit reached (${currentCount}/${limit}). Upgrade to create more bookmarks.`
+          };
+        }
+        return { canCreate: true, current: currentCount, max: limit };
+      } catch (error) {
+        log.error("[LICENSE] Error checking bookmark limit:", error);
+        return { canCreate: true, current: 0, max: 10 };
       }
-      const BOOKMARK_UID2 = "plugin::magic-mark.bookmark";
-      const bookmarks = await strapi.documents(BOOKMARK_UID2).findMany({
-        filters: { creatorId: userId }
-      });
-      const currentCount = bookmarks?.length || 0;
-      if (currentCount >= limit) {
+    },
+    /**
+     * Get current license limits and feature flags
+     * @param userId - User's documentId for bookmark count
+     * @returns License limits object
+     */
+    async getLicenseLimits(userId) {
+      try {
+        const license2 = await this.getCurrentLicense();
+        log.info("[LICENSE] getLicenseLimits - license exists:", !!license2);
+        if (license2) {
+          log.info("[LICENSE] getLicenseLimits - featurePremium:", license2.featurePremium);
+          log.info("[LICENSE] getLicenseLimits - featureAdvanced:", license2.featureAdvanced);
+        }
+        let tier = "free";
+        if (license2?.featureEnterprise === true) tier = "enterprise";
+        else if (license2?.featureAdvanced === true) tier = "advanced";
+        else if (license2?.featurePremium === true) tier = "premium";
+        const isPremium = tier === "premium" || tier === "advanced" || tier === "enterprise";
+        const isAdvanced = tier === "advanced" || tier === "enterprise";
+        log.info("[LICENSE] getLicenseLimits - detected tier:", tier);
+        const bookmarkCheck = await this.canCreateBookmark(userId);
         return {
-          canCreate: false,
-          current: currentCount,
-          max: limit,
-          message: `Bookmark limit reached (${currentCount}/${limit}). Upgrade to create more bookmarks.`
+          maxBookmarks: bookmarkCheck.max,
+          currentBookmarks: bookmarkCheck.current,
+          canCreate: bookmarkCheck.canCreate,
+          tier,
+          features: {
+            queryHistory: isPremium || isAdvanced,
+            export: isPremium || isAdvanced,
+            analytics: isAdvanced,
+            bulkOperations: isAdvanced,
+            customIntegrations: isAdvanced
+          }
+        };
+      } catch (error) {
+        log.error("[LICENSE] Error getting license limits:", error);
+        return {
+          maxBookmarks: 10,
+          currentBookmarks: 0,
+          canCreate: true,
+          tier: "free",
+          features: {
+            queryHistory: false,
+            export: false,
+            analytics: false,
+            bulkOperations: false,
+            customIntegrations: false
+          }
         };
       }
-      return { canCreate: true, current: currentCount, max: limit };
-    } catch (error) {
-      strapi.log.error("[LICENSE] Error checking bookmark limit:", error);
-      return { canCreate: true, current: 0, max: 10 };
-    }
-  },
-  /**
-   * Get current license limits and feature flags
-   * @param userId - User's documentId for bookmark count
-   * @returns License limits object
-   */
-  async getLicenseLimits(userId) {
-    try {
-      const license2 = await this.getCurrentLicense();
-      strapi.log.info("[LICENSE] getLicenseLimits - license exists:", !!license2);
-      if (license2) {
-        strapi.log.info("[LICENSE] getLicenseLimits - featurePremium:", license2.featurePremium);
-        strapi.log.info("[LICENSE] getLicenseLimits - featureAdvanced:", license2.featureAdvanced);
-      }
-      let tier = "free";
-      if (license2?.featureEnterprise === true) tier = "enterprise";
-      else if (license2?.featureAdvanced === true) tier = "advanced";
-      else if (license2?.featurePremium === true) tier = "premium";
-      const isPremium = tier === "premium" || tier === "advanced" || tier === "enterprise";
-      const isAdvanced = tier === "advanced" || tier === "enterprise";
-      strapi.log.info("[LICENSE] getLicenseLimits - detected tier:", tier);
-      const bookmarkCheck = await this.canCreateBookmark(userId);
-      return {
-        maxBookmarks: bookmarkCheck.max,
-        currentBookmarks: bookmarkCheck.current,
-        canCreate: bookmarkCheck.canCreate,
-        tier,
-        features: {
-          queryHistory: isPremium || isAdvanced,
-          export: isPremium || isAdvanced,
-          analytics: isAdvanced,
-          bulkOperations: isAdvanced,
-          customIntegrations: isAdvanced
-        }
-      };
-    } catch (error) {
-      strapi.log.error("[LICENSE] Error getting license limits:", error);
-      return {
-        maxBookmarks: 10,
-        currentBookmarks: 0,
-        canCreate: true,
-        tier: "free",
-        features: {
-          queryHistory: false,
-          export: false,
-          analytics: false,
-          bulkOperations: false,
-          customIntegrations: false
-        }
-      };
-    }
-  },
-  /**
-   * Check if a specific feature is available based on license
-   * @param feature - Feature key to check
-   * @returns Boolean indicating if feature is available
-   */
-  hasFeature(feature) {
-    try {
-      const licenseGuard = strapi.licenseGuard;
-      const licenseData = licenseGuard?.data;
-      const isPremium = licenseData?.featurePremium || false;
-      const isAdvanced = licenseData?.featureAdvanced || false;
-      const featureRequirements = {
-        // Free tier
-        basicBookmarks: "free",
-        basicFilters: "free",
-        // Premium tier
-        extendedBookmarks: "premium",
-        queryHistory: "premium",
-        exportBookmarks: "premium",
-        sharedBookmarks: "premium",
-        // Advanced tier
-        unlimitedBookmarks: "advanced",
-        advancedFilters: "advanced",
-        subGroups: "advanced",
-        bulkOperations: "advanced",
-        analytics: "advanced",
-        customIntegrations: "advanced"
-      };
-      const requiredTier = featureRequirements[feature] || "free";
-      let currentTierLevel = 0;
-      if (isAdvanced) currentTierLevel = 2;
-      else if (isPremium) currentTierLevel = 1;
-      const tierLevels = {
-        free: 0,
-        premium: 1,
-        advanced: 2
-      };
-      return currentTierLevel >= tierLevels[requiredTier];
-    } catch (error) {
-      strapi.log.debug("[LICENSE] Error checking feature:", feature);
-      return false;
-    }
-  },
-  /**
-   * Get current tier name
-   * @returns 'free' | 'premium' | 'advanced'
-   */
-  getCurrentTier() {
-    try {
+    },
+    /**
+     * Check if a specific feature is available based on license
+     * @param feature - Feature key to check
+     * @returns Boolean indicating if feature is available
+     */
+    hasFeature(feature) {
+      try {
+        const licenseGuard = strapi.licenseGuard;
+        const licenseData = licenseGuard?.data;
+        const isPremium = licenseData?.featurePremium || false;
+        const isAdvanced = licenseData?.featureAdvanced || false;
+        const featureRequirements = {
+          // Free tier
+          basicBookmarks: "free",
+          basicFilters: "free",
+          // Premium tier
+          extendedBookmarks: "premium",
+          queryHistory: "premium",
+          exportBookmarks: "premium",
+          sharedBookmarks: "premium",
+          // Advanced tier
+          unlimitedBookmarks: "advanced",
+          advancedFilters: "advanced",
+          subGroups: "advanced",
+          bulkOperations: "advanced",
+          analytics: "advanced",
+          customIntegrations: "advanced"
+        };
+        const requiredTier = featureRequirements[feature] || "free";
+        let currentTierLevel = 0;
+        if (isAdvanced) currentTierLevel = 2;
+        else if (isPremium) currentTierLevel = 1;
+        const tierLevels = {
+          free: 0,
+          premium: 1,
+          advanced: 2
+        };
+        return currentTierLevel >= tierLevels[requiredTier];
+      } catch (error) {
+        log.debug("[LICENSE] Error checking feature:", feature);
+        return false;
+      }
+    },
+    /**
+     * Get current tier name
+     * @returns 'free' | 'premium' | 'advanced'
+     */
+    getCurrentTier() {
+      try {
+        const licenseGuard = strapi.licenseGuard;
+        const licenseData = licenseGuard?.data;
+        if (licenseData?.featureAdvanced) return "advanced";
+        if (licenseData?.featurePremium) return "premium";
+        return "free";
+      } catch (error) {
+        return "free";
+      }
+    },
+    /**
+     * Cleanup on plugin destroy
+     */
+    cleanup() {
       const licenseGuard = strapi.licenseGuard;
-      const licenseData = licenseGuard?.data;
-      if (licenseData?.featureAdvanced) return "advanced";
-      if (licenseData?.featurePremium) return "premium";
-      return "free";
-    } catch (error) {
-      return "free";
-    }
-  },
-  /**
-   * Cleanup on plugin destroy
-   */
-  cleanup() {
-    const licenseGuard = strapi.licenseGuard;
-    if (licenseGuard && licenseGuard.pingInterval) {
-      clearInterval(licenseGuard.pingInterval);
-      strapi.log.info("[STOP] License pinging stopped");
+      if (licenseGuard && licenseGuard.pingInterval) {
+        clearInterval(licenseGuard.pingInterval);
+        log.info("[STOP] License pinging stopped");
+      }
     }
-  }
-});
+  };
+};
 const services = {
   bookmarks: bookmarkService,
   "license-guard": licenseGuardService