strapi-plugin-magic-mark 1.1.0

package/dist/server/index.mjs

@@ -0,0 +1,1307 @@
+import crypto from "crypto";
+import os from "os";
+const magicMarkActions = {
+  actions: [
+    {
+      section: "plugins",
+      displayName: "Read",
+      uid: "settings.read",
+      subCategory: "Settings",
+      pluginName: "magic-mark"
+    },
+    {
+      section: "plugins",
+      displayName: "Edit",
+      uid: "settings.update",
+      subCategory: "Settings",
+      pluginName: "magic-mark"
+    }
+  ]
+};
+const register = async ({ strapi }) => {
+  await strapi.admin.services.permission.actionProvider.registerMany(
+    magicMarkActions.actions
+  );
+  strapi.log.info("[Magic-Mark] Plugin registered successfully");
+};
+const bootstrap = ({ strapi }) => {
+  strapi.log.info("[Magic-Mark] 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("║  ❌ 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("╚════════════════════════════════════════════════════════════════╝");
+      } 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("║  ✅ MAGICMARK PLUGIN LICENSE ACTIVE                            ║");
+        strapi.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) + "║");
+        } else if (storedKey) {
+          strapi.log.info(`║  License: ${storedKey} (Offline Mode)                         ║`);
+          strapi.log.info(`║  Status: Grace Period Active                                  ║`);
+        }
+        strapi.log.info("║                                                                ║");
+        strapi.log.info("║  🔄 Auto-pinging every 15 minutes                              ║");
+        strapi.log.info("╚════════════════════════════════════════════════════════════════╝");
+      }
+    }, 3e3);
+  } catch (error) {
+    strapi.log.error("❌ Error initializing License Guard:", error);
+  }
+  strapi.log.info("[Magic-Mark] Plugin bootstrapped successfully");
+};
+const destroy = ({ strapi }) => {
+  try {
+    const licenseGuardService2 = strapi.plugin("magic-mark")?.service("license-guard");
+    if (licenseGuardService2) {
+      licenseGuardService2.cleanup();
+      strapi.log.info("✅ License Guard cleanup completed");
+    }
+  } catch (error) {
+    strapi.log.error("❌ Error during License Guard cleanup:", error);
+  }
+};
+const config = {
+  default: {},
+  validator: () => {
+  }
+};
+const contentTypes = {
+  bookmark: {
+    schema: {
+      kind: "collectionType",
+      collectionName: "magic_bookmarks",
+      info: {
+        singularName: "bookmark",
+        pluralName: "bookmarks",
+        displayName: "Magic Bookmark",
+        description: "Saved filter views for quick access with path and query parameters"
+      },
+      options: {
+        draftAndPublish: false,
+        comment: "Magic Bookmarks - Saved Views with Filters"
+      },
+      pluginOptions: {
+        "content-manager": { visible: false },
+        "content-type-builder": { visible: false }
+      },
+      attributes: {
+        name: {
+          type: "string",
+          required: true,
+          maxLength: 100,
+          configurable: false
+        },
+        // Path: /content-manager/collection-types/api::article.article
+        path: {
+          type: "string",
+          required: true,
+          configurable: false,
+          description: "Content Manager path (e.g., /content-manager/collection-types/api::article.article)"
+        },
+        // Query: filters[status][$eq]=published&sort=createdAt:DESC
+        query: {
+          type: "text",
+          configurable: false,
+          description: "URL query parameters (e.g., filters[status][$eq]=published&sort=createdAt:DESC)"
+        },
+        emoji: {
+          type: "string",
+          default: "🔖",
+          configurable: false,
+          maxLength: 2
+        },
+        isPinned: {
+          type: "boolean",
+          default: false,
+          configurable: false
+        },
+        order: {
+          type: "integer",
+          default: 0,
+          configurable: false
+        },
+        description: {
+          type: "text",
+          configurable: false
+        },
+        // Array of role IDs that have access to this bookmark
+        sharedWithRoles: {
+          type: "json",
+          configurable: false,
+          description: "Array of role IDs that have access to this bookmark"
+        },
+        // Array of user IDs that have direct access to this bookmark
+        sharedWithUsers: {
+          type: "json",
+          configurable: false,
+          description: "Array of user IDs that have direct access to this bookmark"
+        },
+        // Whether this bookmark is public to all admin users
+        isPublic: {
+          type: "boolean",
+          default: false,
+          configurable: false,
+          description: "If true, all admin users can see this bookmark"
+        }
+      }
+    }
+  }
+};
+const bookmarkController = ({ strapi }) => ({
+  async getAll(ctx) {
+    try {
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.throw(401, "User not authenticated");
+      }
+      const bookmarks = await strapi.plugin("magic-mark").service("bookmarks").findAll(user.id);
+      ctx.body = {
+        data: bookmarks,
+        meta: {
+          count: bookmarks.length
+        }
+      };
+    } catch (error) {
+      ctx.throw(500, `Error fetching bookmarks: ${error}`);
+    }
+  },
+  async create(ctx) {
+    try {
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.throw(401, "User not authenticated");
+      }
+      const { name, path, query, emoji, description, sharedWithRoles, sharedWithUsers, isPublic } = ctx.request.body;
+      if (!name || name.trim().length === 0) {
+        return ctx.throw(400, "Name is required");
+      }
+      if (!path || path.trim().length === 0) {
+        return ctx.throw(400, "Path is required");
+      }
+      const service = strapi.plugin("magic-mark").service("bookmarks");
+      const bookmark = await service.create(name, path, query, emoji, description, user.id, sharedWithRoles, sharedWithUsers, isPublic);
+      ctx.body = {
+        data: bookmark
+      };
+    } catch (error) {
+      ctx.throw(500, `Error creating bookmark: ${error}`);
+    }
+  },
+  async update(ctx) {
+    try {
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.throw(401, "User not authenticated");
+      }
+      const { id } = ctx.params;
+      const { name, path, query, emoji, description, isPinned, order, sharedWithRoles, sharedWithUsers, isPublic } = ctx.request.body;
+      if (!name || name.trim().length === 0) {
+        return ctx.throw(400, "Name is required");
+      }
+      if (!path || path.trim().length === 0) {
+        return ctx.throw(400, "Path is required");
+      }
+      const bookmark = await strapi.plugin("magic-mark").service("bookmarks").update(id, { name, path, query, emoji, description, isPinned, order, sharedWithRoles, sharedWithUsers, isPublic }, user.id);
+      ctx.body = {
+        data: bookmark
+      };
+    } catch (error) {
+      ctx.throw(500, `Error updating bookmark: ${error}`);
+    }
+  },
+  async delete(ctx) {
+    try {
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.throw(401, "User not authenticated");
+      }
+      const { id } = ctx.params;
+      await strapi.plugin("magic-mark").service("bookmarks").delete(id);
+      ctx.body = {
+        data: { success: true }
+      };
+    } catch (error) {
+      ctx.throw(500, `Error deleting bookmark: ${error}`);
+    }
+  },
+  async pin(ctx) {
+    try {
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.throw(401, "User not authenticated");
+      }
+      const { id } = ctx.params;
+      const { isPinned } = ctx.request.body;
+      const bookmark = await strapi.plugin("magic-mark").service("bookmarks").pin(id, isPinned, user.id);
+      ctx.body = {
+        data: bookmark
+      };
+    } catch (error) {
+      ctx.throw(500, `Error pinning bookmark: ${error}`);
+    }
+  },
+  async reorder(ctx) {
+    try {
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.throw(401, "User not authenticated");
+      }
+      const { bookmarkIds } = ctx.request.body;
+      if (!bookmarkIds || !Array.isArray(bookmarkIds)) {
+        return ctx.throw(400, "Bookmark IDs array is required");
+      }
+      const bookmarks = await strapi.plugin("magic-mark").service("bookmarks").reorder(bookmarkIds, user.id);
+      ctx.body = {
+        data: bookmarks
+      };
+    } catch (error) {
+      ctx.throw(500, `Error reordering bookmarks: ${error}`);
+    }
+  },
+  async getRoles(ctx) {
+    try {
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.throw(401, "User not authenticated");
+      }
+      const roles = await strapi.entityService.findMany(
+        "admin::role",
+        {
+          fields: ["id", "name", "code", "description", "createdAt", "updatedAt"],
+          filters: {},
+          sort: { name: "asc" },
+          populate: ["users"]
+          // Also get user count for each role
+        }
+      );
+      const rolesWithDetails = roles?.map((role) => ({
+        id: role.id,
+        name: role.name,
+        code: role.code,
+        description: role.description,
+        userCount: role.users?.length || 0,
+        isCustom: !["super_admin", "editor", "author"].includes(role.code)
+        // Mark custom roles
+      })) || [];
+      ctx.body = {
+        data: {
+          data: rolesWithDetails
+        }
+      };
+    } catch (error) {
+      ctx.throw(500, `Error fetching roles: ${error}`);
+    }
+  },
+  async getUsers(ctx) {
+    try {
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.throw(401, "User not authenticated");
+      }
+      let users = [];
+      try {
+        const adminUserService = strapi.admin?.services?.user || strapi.service("admin::user");
+        if (adminUserService?.findPage) {
+          const results = await adminUserService.findPage({
+            pagination: {
+              page: 1,
+              pageSize: 100
+            }
+          });
+          users = results.results || [];
+        } else if (adminUserService?.find) {
+          users = await adminUserService.find();
+        }
+      } catch (err) {
+        console.log("[Magic-Mark] Admin service error, trying entity service:", err);
+      }
+      if (!users || users.length === 0) {
+        try {
+          users = await strapi.entityService.findMany("admin::user", {
+            limit: 100
+          });
+        } catch (err) {
+          console.log("[Magic-Mark] Entity service error:", err);
+        }
+      }
+      if (!users || users.length === 0) {
+        try {
+          users = await strapi.db.query("admin::user").findMany({
+            limit: 100
+          });
+        } catch (err) {
+          console.log("[Magic-Mark] DB query error:", err);
+        }
+      }
+      const filteredUsers = users.filter((u) => u.id !== user.id);
+      console.log("[Magic-Mark] Total admin users found:", users.length);
+      console.log("[Magic-Mark] Filtered users (excluding current):", filteredUsers.map((u) => ({
+        id: u.id,
+        name: `${u.firstname} ${u.lastname}`,
+        email: u.email
+      })));
+      ctx.body = {
+        data: {
+          data: filteredUsers.map((u) => ({
+            id: u.id,
+            firstname: u.firstname || "",
+            lastname: u.lastname || "",
+            email: u.email,
+            username: u.username || u.email
+          }))
+        }
+      };
+    } catch (error) {
+      ctx.throw(500, `Error fetching users: ${error}`);
+    }
+  }
+});
+const license = ({ strapi }) => ({
+  /**
+   * Auto-create license with logged-in admin user data
+   */
+  async autoCreate(ctx) {
+    try {
+      const adminUser = ctx.state.user;
+      if (!adminUser) {
+        return ctx.unauthorized("No admin user logged in");
+      }
+      const licenseGuard = strapi.plugin("magic-mark").service("license-guard");
+      const license2 = await licenseGuard.createLicense({
+        email: adminUser.email,
+        firstName: adminUser.firstname || "Admin",
+        lastName: adminUser.lastname || "User"
+      });
+      if (!license2) {
+        return ctx.badRequest("Failed to create license");
+      }
+      await licenseGuard.storeLicenseKey(license2.licenseKey);
+      const pingInterval = licenseGuard.startPinging(license2.licenseKey, 15);
+      strapi.licenseGuard = {
+        licenseKey: license2.licenseKey,
+        pingInterval,
+        data: license2
+      };
+      return ctx.send({
+        success: true,
+        message: "License automatically created and activated",
+        data: license2
+      });
+    } catch (error) {
+      strapi.log.error("Error auto-creating license:", error);
+      return ctx.badRequest("Error creating license");
+    }
+  },
+  /**
+   * Get current license status
+   */
+  async getStatus(ctx) {
+    try {
+      const licenseGuard = strapi.plugin("magic-mark").service("license-guard");
+      const pluginStore = strapi.store({
+        type: "plugin",
+        name: "magic-mark"
+      });
+      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."
+        });
+      }
+      const verification = await licenseGuard.verifyLicense(licenseKey);
+      const license2 = await licenseGuard.getLicenseByKey(licenseKey);
+      return ctx.send({
+        success: true,
+        valid: verification.valid,
+        demo: false,
+        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
+          },
+          maxDevices: license2?.maxDevices || 1,
+          currentDevices: license2?.currentDevices || 0
+        }
+      });
+    } catch (error) {
+      strapi.log.error("Error getting license status:", error);
+      return ctx.badRequest("Error getting license status");
+    }
+  },
+  /**
+   * Create and activate a new license
+   */
+  async createAndActivate(ctx) {
+    try {
+      const { email, firstName, lastName } = ctx.request.body;
+      if (!email || !firstName || !lastName) {
+        return ctx.badRequest("Email, firstName, and lastName are required");
+      }
+      const licenseGuard = strapi.plugin("magic-mark").service("license-guard");
+      const license2 = await licenseGuard.createLicense({ email, firstName, lastName });
+      if (!license2) {
+        return ctx.badRequest("Failed to create license");
+      }
+      await licenseGuard.storeLicenseKey(license2.licenseKey);
+      const pingInterval = licenseGuard.startPinging(license2.licenseKey, 15);
+      strapi.licenseGuard = {
+        licenseKey: license2.licenseKey,
+        pingInterval,
+        data: license2
+      };
+      return ctx.send({
+        success: true,
+        message: "License created and activated successfully",
+        data: license2
+      });
+    } catch (error) {
+      strapi.log.error("Error creating license:", error);
+      return ctx.badRequest("Error creating license");
+    }
+  },
+  /**
+   * Manually ping the current license
+   */
+  async ping(ctx) {
+    try {
+      const pluginStore = strapi.store({
+        type: "plugin",
+        name: "magic-mark"
+      });
+      const licenseKey = await pluginStore.get({ key: "licenseKey" });
+      if (!licenseKey) {
+        return ctx.badRequest("No license key found");
+      }
+      const licenseGuard = strapi.plugin("magic-mark").service("license-guard");
+      const pingResult = await licenseGuard.pingLicense(licenseKey);
+      if (!pingResult) {
+        return ctx.badRequest("Ping failed");
+      }
+      return ctx.send({
+        success: true,
+        message: "License pinged successfully",
+        data: pingResult
+      });
+    } catch (error) {
+      strapi.log.error("Error pinging license:", error);
+      return ctx.badRequest("Error pinging license");
+    }
+  },
+  /**
+   * Store and validate an existing license key
+   */
+  async storeKey(ctx) {
+    try {
+      const { licenseKey, email } = ctx.request.body;
+      if (!licenseKey || !licenseKey.trim()) {
+        return ctx.badRequest("License key is required");
+      }
+      if (!email || !email.trim()) {
+        return ctx.badRequest("Email address is required");
+      }
+      const trimmedKey = licenseKey.trim();
+      const trimmedEmail = email.trim().toLowerCase();
+      const licenseGuard = strapi.plugin("magic-mark").service("license-guard");
+      const verification = await licenseGuard.verifyLicense(trimmedKey);
+      if (!verification.valid) {
+        strapi.log.warn(`⚠️ Invalid license key attempted: ${trimmedKey.substring(0, 8)}...`);
+        return ctx.badRequest("Invalid or expired license key");
+      }
+      const license2 = await licenseGuard.getLicenseByKey(trimmedKey);
+      if (!license2) {
+        strapi.log.warn(`⚠️ License not found in database: ${trimmedKey.substring(0, 8)}...`);
+        return ctx.badRequest("License not found");
+      }
+      if (license2.email.toLowerCase() !== trimmedEmail) {
+        strapi.log.warn(`⚠️ Email mismatch for license key: ${trimmedKey.substring(0, 8)}... (Attempted: ${trimmedEmail})`);
+        return ctx.badRequest("Email address does not match this license key");
+      }
+      await licenseGuard.storeLicenseKey(trimmedKey);
+      const pingInterval = licenseGuard.startPinging(trimmedKey, 15);
+      strapi.licenseGuard = {
+        licenseKey: trimmedKey,
+        pingInterval,
+        data: verification.data
+      };
+      strapi.log.info(`✅ Existing license key validated and stored: ${trimmedKey.substring(0, 8)}... (Email: ${trimmedEmail})`);
+      return ctx.send({
+        success: true,
+        message: "License key validated and activated successfully",
+        data: verification.data
+      });
+    } catch (error) {
+      strapi.log.error("Error storing license key:", error);
+      return ctx.badRequest("Error validating license key");
+    }
+  }
+});
+const controllers = {
+  bookmarks: bookmarkController,
+  license
+};
+const admin = {
+  type: "admin",
+  routes: [
+    // Get available roles for sharing
+    {
+      method: "GET",
+      path: "/roles",
+      handler: "bookmarks.getRoles",
+      config: {
+        policies: []
+      }
+    },
+    // Get available users for sharing
+    {
+      method: "GET",
+      path: "/users",
+      handler: "bookmarks.getUsers",
+      config: {
+        policies: []
+      }
+    },
+    // Get all bookmarks
+    {
+      method: "GET",
+      path: "/bookmarks",
+      handler: "bookmarks.getAll",
+      config: {
+        policies: []
+      }
+    },
+    // Reorder bookmarks (SPECIFIC - must come before :id routes)
+    {
+      method: "POST",
+      path: "/bookmarks/reorder",
+      handler: "bookmarks.reorder",
+      config: {
+        policies: []
+      }
+    },
+    // Pin/Unpin bookmark (SPECIFIC - must come before generic :id)
+    {
+      method: "POST",
+      path: "/bookmarks/:id/pin",
+      handler: "bookmarks.pin",
+      config: {
+        policies: []
+      }
+    },
+    // Create bookmark
+    {
+      method: "POST",
+      path: "/bookmarks",
+      handler: "bookmarks.create",
+      config: {
+        policies: []
+      }
+    },
+    // Update bookmark
+    {
+      method: "PUT",
+      path: "/bookmarks/:id",
+      handler: "bookmarks.update",
+      config: {
+        policies: []
+      }
+    },
+    // Delete bookmark
+    {
+      method: "DELETE",
+      path: "/bookmarks/:id",
+      handler: "bookmarks.delete",
+      config: {
+        policies: []
+      }
+    },
+    // License Management
+    {
+      method: "GET",
+      path: "/license/status",
+      handler: "license.getStatus",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "POST",
+      path: "/license/auto-create",
+      handler: "license.autoCreate",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "POST",
+      path: "/license/create",
+      handler: "license.createAndActivate",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "POST",
+      path: "/license/ping",
+      handler: "license.ping",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "POST",
+      path: "/license/store-key",
+      handler: "license.storeKey",
+      config: {
+        policies: []
+      }
+    }
+  ]
+};
+const contentApi = {
+  type: "content-api",
+  routes: []
+};
+const routes = {
+  admin,
+  "content-api": contentApi
+};
+const licenseCheck$1 = (config2, { strapi }) => {
+  return async (ctx, next) => {
+    if (ctx.request.url.includes("/magic-mark/license/")) {
+      return await next();
+    }
+    if (ctx.request.url.includes("/admin/login")) {
+      return await next();
+    }
+    try {
+      const licenseGuard = strapi.plugin("magic-mark")?.service("license-guard");
+      if (!licenseGuard) {
+        return await next();
+      }
+      const pluginStore = strapi.store({
+        type: "plugin",
+        name: "magic-mark"
+      });
+      const licenseKey = await pluginStore.get({ key: "licenseKey" });
+      if (!licenseKey) {
+        strapi.log.warn("⚠️ MagicMark: No license key found");
+        return await next();
+      }
+      const verification = await licenseGuard.verifyLicense(licenseKey, true);
+      if (!verification.valid && !verification.gracePeriod) {
+        strapi.log.warn("⚠️ MagicMark: Invalid license detected");
+      }
+      return await next();
+    } catch (error) {
+      strapi.log.error("Error in license check middleware:", error);
+      return await next();
+    }
+  };
+};
+const middlewares = {
+  "license-check": licenseCheck$1
+};
+const licenseCheck = async (policyContext, config2, { strapi }) => {
+  try {
+    const licenseGuard = strapi.plugin("magic-mark").service("license-guard");
+    const pluginStore = strapi.store({ type: "plugin", name: "magic-mark" });
+    const licenseKey = await pluginStore.get({ key: "licenseKey" });
+    if (!licenseKey) {
+      strapi.log.warn("⚠️ API access denied: No license key found");
+      return policyContext.unauthorized("No license found. Please activate the plugin first.");
+    }
+    const verification = await licenseGuard.verifyLicense(licenseKey);
+    if (!verification.valid) {
+      strapi.log.warn("⚠️ API access denied: Invalid license");
+      return policyContext.unauthorized("Invalid or expired license. Please check your license status.");
+    }
+    const license2 = await licenseGuard.getLicenseByKey(licenseKey);
+    if (!license2) {
+      strapi.log.warn("⚠️ API access denied: License not found in database");
+      return policyContext.unauthorized("License not found. Please contact support.");
+    }
+    if (!license2.isActive) {
+      strapi.log.warn("⚠️ API access denied: License is inactive");
+      return policyContext.unauthorized("License is inactive. Please activate your license.");
+    }
+    if (license2.isExpired) {
+      strapi.log.warn("⚠️ API access denied: License has expired");
+      return policyContext.unauthorized("License has expired. Please renew your license.");
+    }
+    return true;
+  } catch (error) {
+    strapi.log.error("Error checking license:", error);
+    return policyContext.unauthorized("Error verifying license. Please try again.");
+  }
+};
+const policies = {
+  "license-check": licenseCheck
+};
+const bookmarkService = ({ strapi }) => ({
+  async findAll(userId) {
+    try {
+      const user = await strapi.entityService.findOne(
+        "admin::user",
+        userId,
+        {
+          populate: ["roles"]
+        }
+      );
+      const userRoleIds = user?.roles?.map((role) => role.id) || [];
+      const allBookmarks = await strapi.entityService.findMany(
+        "plugin::magic-mark.bookmark",
+        {
+          sort: [
+            { isPinned: "desc" },
+            { order: "asc" }
+          ],
+          populate: ["createdBy"]
+        }
+      );
+      const accessibleBookmarks = allBookmarks?.filter((bookmark) => {
+        if (bookmark.createdBy?.id === userId) {
+          return true;
+        }
+        if (bookmark.isPublic) {
+          return true;
+        }
+        if (bookmark.sharedWithUsers && Array.isArray(bookmark.sharedWithUsers)) {
+          if (bookmark.sharedWithUsers.includes(userId)) {
+            return true;
+          }
+        }
+        if (bookmark.sharedWithRoles && Array.isArray(bookmark.sharedWithRoles)) {
+          return bookmark.sharedWithRoles.some(
+            (roleId) => userRoleIds.includes(roleId)
+          );
+        }
+        return false;
+      }) || [];
+      return accessibleBookmarks;
+    } catch (error) {
+      strapi.log.error("[magic-mark] Error finding bookmarks:", error);
+      throw error;
+    }
+  },
+  async create(name, path, query, emoji, description, userId, sharedWithRoles, sharedWithUsers, isPublic) {
+    try {
+      const bookmarks = await strapi.entityService.findMany(
+        "plugin::magic-mark.bookmark",
+        {
+          sort: [{ order: "desc" }],
+          limit: 1
+        }
+      );
+      const maxOrder = bookmarks && bookmarks.length > 0 ? bookmarks[0].order : 0;
+      const bookmark = await strapi.entityService.create(
+        "plugin::magic-mark.bookmark",
+        {
+          data: {
+            name,
+            path,
+            query: query || "",
+            emoji: emoji || "🔖",
+            description,
+            isPinned: false,
+            order: (maxOrder || 0) + 1,
+            createdBy: userId,
+            sharedWithRoles: sharedWithRoles || [],
+            sharedWithUsers: sharedWithUsers || [],
+            isPublic: isPublic || false
+          }
+        }
+      );
+      return bookmark;
+    } catch (error) {
+      strapi.log.error("[magic-mark] Error creating bookmark:", error);
+      throw error;
+    }
+  },
+  async update(id, data, userId) {
+    try {
+      const existingBookmark = await strapi.entityService.findOne(
+        "plugin::magic-mark.bookmark",
+        id,
+        {
+          populate: ["createdBy"]
+        }
+      );
+      if (!existingBookmark || existingBookmark.createdBy?.id !== userId) {
+        throw new Error("Unauthorized: You can only edit your own bookmarks");
+      }
+      const bookmark = await strapi.entityService.update(
+        "plugin::magic-mark.bookmark",
+        id,
+        {
+          data: {
+            name: data.name,
+            path: data.path,
+            query: data.query || "",
+            emoji: data.emoji || "🔖",
+            description: data.description,
+            isPinned: data.isPinned,
+            order: data.order,
+            sharedWithRoles: data.sharedWithRoles,
+            sharedWithUsers: data.sharedWithUsers,
+            isPublic: data.isPublic,
+            updatedBy: userId
+          }
+        }
+      );
+      return bookmark;
+    } catch (error) {
+      strapi.log.error("[magic-mark] Error updating bookmark:", error);
+      throw error;
+    }
+  },
+  async delete(id) {
+    try {
+      return await strapi.entityService.delete(
+        "plugin::magic-mark.bookmark",
+        id
+      );
+    } catch (error) {
+      strapi.log.error("[magic-mark] Error deleting bookmark:", error);
+      throw error;
+    }
+  },
+  async pin(id, isPinned, userId) {
+    try {
+      const bookmark = await strapi.entityService.update(
+        "plugin::magic-mark.bookmark",
+        id,
+        {
+          data: {
+            isPinned,
+            updatedBy: userId
+          }
+        }
+      );
+      return bookmark;
+    } catch (error) {
+      strapi.log.error("[magic-mark] Error pinning bookmark:", error);
+      throw error;
+    }
+  },
+  async reorder(bookmarkIds, userId) {
+    try {
+      const updates = bookmarkIds.map(
+        (id, index2) => strapi.entityService.update(
+          "plugin::magic-mark.bookmark",
+          id,
+          {
+            data: {
+              order: index2,
+              updatedBy: userId
+            }
+          }
+        )
+      );
+      return Promise.all(updates);
+    } catch (error) {
+      strapi.log.error("[magic-mark] Error reordering bookmarks:", error);
+      throw error;
+    }
+  },
+  validateUrl(url) {
+    try {
+      new URL(url);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+});
+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 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;
+            }
+          }
+        }
+      }
+      return "127.0.0.1";
+    } catch (error) {
+      return "127.0.0.1";
+    }
+  },
+  /**
+   * Get user agent (server context)
+   */
+  getUserAgent() {
+    return `Strapi/${strapi.config.get("info.strapi") || "5.0.0"} 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("✅ License created successfully:", data.data.licenseKey);
+        return data.data;
+      } else {
+        strapi.log.error("❌ License creation failed:", data);
+        return null;
+      }
+    } catch (error) {
+      strapi.log.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(`✅ 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 {
+        strapi.log.warn(`⚠️ License verification failed: ${data.message || "Unknown error"} (Key: ${licenseKey?.substring(0, 8)}...)`);
+        return { valid: false, data: null };
+      }
+    } catch (error) {
+      if (allowGracePeriod) {
+        strapi.log.warn(`⚠️ Cannot verify license online: ${error.message} (Key: ${licenseKey?.substring(0, 8)}...)`);
+        strapi.log.info(`🕐 Grace period active - accepting stored license key`);
+        return { valid: true, data: null, gracePeriod: true };
+      }
+      strapi.log.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(`📡 License ping successful: ${data.data?.isActive ? "ACTIVE" : "INACTIVE"} (Key: ${licenseKey?.substring(0, 8)}...)`);
+        return data.data;
+      } else {
+        strapi.log.debug(`⚠️ License ping failed: ${data.message || "Unknown error"} (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;
+      }
+      return null;
+    } catch (error) {
+      strapi.log.error("❌ Error fetching license by key:", error);
+      return null;
+    }
+  },
+  /**
+   * Get online statistics
+   */
+  async getOnlineStats() {
+    try {
+      const licenseServerUrl = this.getLicenseServerUrl();
+      const response = await fetch(`${licenseServerUrl}/api/licenses/stats/online`);
+      const data = await response.json();
+      if (data.success) {
+        return data.data;
+      }
+      return null;
+    } catch (error) {
+      strapi.log.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);
+    strapi.log.info(`📡 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("🔐 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(`📦 Plugin Store Check:`);
+      if (licenseKey) {
+        strapi.log.info(`   ✅ License Key found: ${licenseKey}`);
+        strapi.log.info(`   🔑 Key (short): ${licenseKey.substring(0, 8)}...`);
+        if (lastValidated) {
+          const lastValidatedDate = new Date(lastValidated);
+          const hoursAgo = Math.floor((now.getTime() - lastValidatedDate.getTime()) / (1e3 * 60 * 60));
+          strapi.log.info(`   🕐 Last validated: ${hoursAgo}h ago (Grace: ${withinGracePeriod ? "ACTIVE" : "EXPIRED"})`);
+        } else {
+          strapi.log.info(`   🕐 Last validated: Never (Grace: ACTIVE for first ${gracePeriodHours}h)`);
+        }
+      } else {
+        strapi.log.info(`   ❌ No license key stored`);
+      }
+      strapi.log.info("──────────────────────────────────────────────────────────");
+      if (licenseKey) {
+        strapi.log.info("📄 Verifying stored license key...");
+        const verification = await this.verifyLicense(licenseKey, true);
+        if (verification.valid) {
+          if (verification.gracePeriod) {
+            strapi.log.info("✅ License accepted (offline mode / grace period)");
+          } else {
+            strapi.log.info("✅ 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 {
+          strapi.log.warn("⚠️ Stored license is invalid or expired");
+          if (!withinGracePeriod) {
+            await pluginStore.delete({ key: "licenseKey" });
+            await pluginStore.delete({ key: "lastValidated" });
+          }
+        }
+      }
+      strapi.log.warn("⚠️ No valid license found. Plugin will run with limited functionality.");
+      return { valid: false, demo: true };
+    } catch (error) {
+      strapi.log.error("❌ Error initializing license guard:", error);
+      return { valid: false, error: error.message };
+    }
+  },
+  /**
+   * Store license key after creation
+   */
+  async storeLicenseKey(licenseKey) {
+    try {
+      strapi.log.info(`🔐 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("✅ License key stored and verified successfully");
+        return true;
+      } else {
+        strapi.log.error("❌ License key storage verification failed");
+        return false;
+      }
+    } catch (error) {
+      strapi.log.error("❌ Error storing license key:", error);
+      return false;
+    }
+  },
+  /**
+   * Cleanup on plugin destroy
+   */
+  cleanup() {
+    const licenseGuard = strapi.licenseGuard;
+    if (licenseGuard && licenseGuard.pingInterval) {
+      clearInterval(licenseGuard.pingInterval);
+      strapi.log.info("🛑 License pinging stopped");
+    }
+  }
+});
+const services = {
+  bookmarks: bookmarkService,
+  "license-guard": licenseGuardService
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+export {
+  index as default
+};