strapi-plugin-magic-mark 2.0.0 → 3.0.1

package/dist/server/index.mjs

@@ -1,5 +1,7 @@
 import crypto from "crypto";
 import os from "os";
+import { readFileSync } from "fs";
+import { join } from "path";
 const magicMarkActions = {
   actions: [
     {
@@ -32,7 +34,7 @@ const bootstrap = ({ strapi }) => {
       const licenseStatus = await licenseGuardService2.initialize();
       if (!licenseStatus.valid) {
         strapi.log.error("╔════════════════════════════════════════════════════════════════╗");
-        strapi.log.error("║  ❌ MAGICMARK PLUGIN - NO VALID LICENSE                        ║");
+        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:                   ║");
@@ -48,7 +50,7 @@ const bootstrap = ({ strapi }) => {
         });
         const storedKey = await pluginStore.get({ key: "licenseKey" });
         strapi.log.info("╔════════════════════════════════════════════════════════════════╗");
-        strapi.log.info("║  ✅ MAGICMARK PLUGIN LICENSE ACTIVE                            ║");
+        strapi.log.info("║  [SUCCESS] MAGICMARK PLUGIN LICENSE ACTIVE                    ║");
         strapi.log.info("║                                                                ║");
         if (licenseStatus.data) {
           strapi.log.info(`║  License: ${licenseStatus.data.licenseKey}                    ║`);
@@ -59,12 +61,12 @@ const bootstrap = ({ strapi }) => {
           strapi.log.info(`║  Status: Grace Period Active                                  ║`);
         }
         strapi.log.info("║                                                                ║");
-        strapi.log.info("║  🔄 Auto-pinging every 15 minutes                              ║");
+        strapi.log.info("║  [PING] Auto-pinging every 15 minutes                         ║");
         strapi.log.info("╚════════════════════════════════════════════════════════════════╝");
       }
     }, 3e3);
   } catch (error) {
-    strapi.log.error("❌ Error initializing License Guard:", error);
+    strapi.log.error("[ERROR] Error initializing License Guard:", error);
   }
   strapi.log.info("[Magic-Mark] Plugin bootstrapped successfully");
 };
@@ -73,10 +75,10 @@ const destroy = ({ strapi }) => {
     const licenseGuardService2 = strapi.plugin("magic-mark")?.service("license-guard");
     if (licenseGuardService2) {
       licenseGuardService2.cleanup();
-      strapi.log.info("✅ License Guard cleanup completed");
+      strapi.log.info("[SUCCESS] License Guard cleanup completed");
     }
   } catch (error) {
-    strapi.log.error("❌ Error during License Guard cleanup:", error);
+    strapi.log.error("[ERROR] Error during License Guard cleanup:", error);
   }
 };
 const config = {
@@ -125,9 +127,9 @@ const contentTypes = {
         },
         emoji: {
           type: "string",
-          default: "🔖",
+          default: "bookmark",
           configurable: false,
-          maxLength: 2
+          maxLength: 50
         },
         isPinned: {
           type: "boolean",
@@ -143,17 +145,30 @@ const contentTypes = {
           type: "text",
           configurable: false
         },
-        // Array of role IDs that have access to this bookmark
+        // Creator's documentId (stored as string, not relation)
+        // We store documentId instead of relation to avoid admin::user permission issues
+        creatorId: {
+          type: "string",
+          configurable: false,
+          description: "documentId of the admin user who created this bookmark"
+        },
+        // Last updater's documentId
+        updaterId: {
+          type: "string",
+          configurable: false,
+          description: "documentId of the admin user who last updated this bookmark"
+        },
+        // Array of role documentIds that have access to this bookmark
         sharedWithRoles: {
           type: "json",
           configurable: false,
-          description: "Array of role IDs that have access to this bookmark"
+          description: "Array of role documentIds that have access to this bookmark"
         },
-        // Array of user IDs that have direct access to this bookmark
+        // Array of user documentIds that have direct access to this bookmark
         sharedWithUsers: {
           type: "json",
           configurable: false,
-          description: "Array of user IDs that have direct access to this bookmark"
+          description: "Array of user documentIds that have direct access to this bookmark"
         },
         // Whether this bookmark is public to all admin users
         isPublic: {
@@ -166,14 +181,21 @@ const contentTypes = {
     }
   }
 };
+const ADMIN_ROLE_UID = "admin::role";
+const ADMIN_USER_UID$1 = "admin::user";
 const bookmarkController = ({ strapi }) => ({
+  /**
+   * Get all bookmarks for current user
+   * GET /magic-mark/bookmarks
+   */
   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);
+      const userId = user.documentId || String(user.id);
+      const bookmarks = await strapi.plugin("magic-mark").service("bookmarks").findAll(userId);
       ctx.body = {
         data: bookmarks,
         meta: {
@@ -184,6 +206,10 @@ const bookmarkController = ({ strapi }) => ({
       ctx.throw(500, `Error fetching bookmarks: ${error}`);
     }
   },
+  /**
+   * Create a new bookmark
+   * POST /magic-mark/bookmarks
+   */
   async create(ctx) {
     try {
       const user = ctx.state.user;
@@ -197,8 +223,9 @@ const bookmarkController = ({ strapi }) => ({
       if (!path || path.trim().length === 0) {
         return ctx.throw(400, "Path is required");
       }
+      const userId = user.documentId || String(user.id);
       const service = strapi.plugin("magic-mark").service("bookmarks");
-      const bookmark = await service.create(name, path, query, emoji, description, user.id, sharedWithRoles, sharedWithUsers, isPublic);
+      const bookmark = await service.create(name, path, query, emoji, description, userId, sharedWithRoles, sharedWithUsers, isPublic);
       ctx.body = {
         data: bookmark
       };
@@ -206,6 +233,10 @@ const bookmarkController = ({ strapi }) => ({
       ctx.throw(500, `Error creating bookmark: ${error}`);
     }
   },
+  /**
+   * Update an existing bookmark
+   * PUT /magic-mark/bookmarks/:id
+   */
   async update(ctx) {
     try {
       const user = ctx.state.user;
@@ -220,7 +251,8 @@ const bookmarkController = ({ strapi }) => ({
       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);
+      const userId = user.documentId || String(user.id);
+      const bookmark = await strapi.plugin("magic-mark").service("bookmarks").update(id, { name, path, query, emoji, description, isPinned, order, sharedWithRoles, sharedWithUsers, isPublic }, userId);
       ctx.body = {
         data: bookmark
       };
@@ -228,6 +260,10 @@ const bookmarkController = ({ strapi }) => ({
       ctx.throw(500, `Error updating bookmark: ${error}`);
     }
   },
+  /**
+   * Delete a bookmark
+   * DELETE /magic-mark/bookmarks/:id
+   */
   async delete(ctx) {
     try {
       const user = ctx.state.user;
@@ -243,6 +279,10 @@ const bookmarkController = ({ strapi }) => ({
       ctx.throw(500, `Error deleting bookmark: ${error}`);
     }
   },
+  /**
+   * Pin or unpin a bookmark
+   * PUT /magic-mark/bookmarks/:id/pin
+   */
   async pin(ctx) {
     try {
       const user = ctx.state.user;
@@ -251,7 +291,8 @@ const bookmarkController = ({ strapi }) => ({
       }
       const { id } = ctx.params;
       const { isPinned } = ctx.request.body;
-      const bookmark = await strapi.plugin("magic-mark").service("bookmarks").pin(id, isPinned, user.id);
+      const userId = user.documentId || String(user.id);
+      const bookmark = await strapi.plugin("magic-mark").service("bookmarks").pin(id, isPinned, userId);
       ctx.body = {
         data: bookmark
       };
@@ -259,6 +300,10 @@ const bookmarkController = ({ strapi }) => ({
       ctx.throw(500, `Error pinning bookmark: ${error}`);
     }
   },
+  /**
+   * Reorder bookmarks
+   * PUT /magic-mark/bookmarks/reorder
+   */
   async reorder(ctx) {
     try {
       const user = ctx.state.user;
@@ -269,7 +314,8 @@ const bookmarkController = ({ strapi }) => ({
       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);
+      const userId = user.documentId || String(user.id);
+      const bookmarks = await strapi.plugin("magic-mark").service("bookmarks").reorder(bookmarkIds, userId);
       ctx.body = {
         data: bookmarks
       };
@@ -277,30 +323,28 @@ const bookmarkController = ({ strapi }) => ({
       ctx.throw(500, `Error reordering bookmarks: ${error}`);
     }
   },
+  /**
+   * Get all admin roles for sharing
+   * GET /magic-mark/roles
+   */
   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 roles = await strapi.documents(ADMIN_ROLE_UID).findMany({
+        fields: ["name", "code", "description", "createdAt", "updatedAt"],
+        sort: { name: "asc" },
+        populate: ["users"]
+      });
       const rolesWithDetails = roles?.map((role) => ({
-        id: role.id,
+        id: role.documentId,
         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: {
@@ -311,6 +355,10 @@ const bookmarkController = ({ strapi }) => ({
       ctx.throw(500, `Error fetching roles: ${error}`);
     }
   },
+  /**
+   * Get all admin users for sharing
+   * GET /magic-mark/users
+   */
   async getUsers(ctx) {
     try {
       const user = ctx.state.user;
@@ -332,37 +380,36 @@ const bookmarkController = ({ strapi }) => ({
           users = await adminUserService.find();
         }
       } catch (err) {
-        console.log("[Magic-Mark] Admin service error, trying entity service:", err);
+        strapi.log.debug("[magic-mark] Admin service not available, trying Document Service");
       }
       if (!users || users.length === 0) {
         try {
-          users = await strapi.entityService.findMany("admin::user", {
+          users = await strapi.documents(ADMIN_USER_UID$1).findMany({
             limit: 100
           });
         } catch (err) {
-          console.log("[Magic-Mark] Entity service error:", err);
+          strapi.log.debug("[magic-mark] Document Service error for admin::user");
         }
       }
       if (!users || users.length === 0) {
         try {
-          users = await strapi.db.query("admin::user").findMany({
+          users = await strapi.entityService.findMany(ADMIN_USER_UID$1, {
             limit: 100
           });
         } catch (err) {
-          console.log("[Magic-Mark] DB query error:", err);
+          strapi.log.warn("[magic-mark] entityService fallback also failed");
         }
       }
-      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
-      })));
+      const currentUserId = user.documentId || String(user.id);
+      const filteredUsers = users.filter((u) => {
+        const uId = u.documentId || String(u.id);
+        return uId !== currentUserId;
+      });
+      strapi.log.debug(`[magic-mark] Total admin users found: ${users.length}`);
       ctx.body = {
         data: {
           data: filteredUsers.map((u) => ({
-            id: u.id,
+            id: u.documentId || u.id,
             firstname: u.firstname || "",
             lastname: u.lastname || "",
             email: u.email,
@@ -540,16 +587,16 @@ const license = ({ strapi }) => ({
       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)}...`);
+        strapi.log.warn(`[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)}...`);
+        strapi.log.warn(`[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})`);
+        strapi.log.warn(`[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);
@@ -559,7 +606,7 @@ const license = ({ strapi }) => ({
         pingInterval,
         data: verification.data
       };
-      strapi.log.info(`✅ Existing license key validated and stored: ${trimmedKey.substring(0, 8)}... (Email: ${trimmedEmail})`);
+      strapi.log.info(`[SUCCESS] Existing license key validated and stored: ${trimmedKey.substring(0, 8)}... (Email: ${trimmedEmail})`);
       return ctx.send({
         success: true,
         message: "License key validated and activated successfully",
@@ -720,12 +767,12 @@ const licenseCheck$1 = (config2, { strapi }) => {
       });
       const licenseKey = await pluginStore.get({ key: "licenseKey" });
       if (!licenseKey) {
-        strapi.log.warn("⚠️ MagicMark: No license key found");
+        strapi.log.warn("[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");
+        strapi.log.warn("[WARN] MagicMark: Invalid license detected");
       }
       return await next();
     } catch (error) {
@@ -743,25 +790,25 @@ const licenseCheck = async (policyContext, config2, { strapi }) => {
     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");
+      strapi.log.warn("[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");
+      strapi.log.warn("[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");
+      strapi.log.warn("[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");
+      strapi.log.warn("[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");
+      strapi.log.warn("[WARN] API access denied: License has expired");
       return policyContext.unauthorized("License has expired. Please renew your license.");
     }
     return true;
@@ -773,29 +820,29 @@ const licenseCheck = async (policyContext, config2, { strapi }) => {
 const policies = {
   "license-check": licenseCheck
 };
+const BOOKMARK_UID = "plugin::magic-mark.bookmark";
+const ADMIN_USER_UID = "admin::user";
 const bookmarkService = ({ strapi }) => ({
+  /**
+   * Find all bookmarks accessible to a user
+   * @param userId - The admin user's documentId
+   * @returns Array of accessible bookmarks
+   */
   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 user = await strapi.documents(ADMIN_USER_UID).findOne({
+        documentId: userId,
+        populate: ["roles"]
+      });
+      const userRoleIds = user?.roles?.map((role) => role.documentId || role.id) || [];
+      const allBookmarks = await strapi.documents(BOOKMARK_UID).findMany({
+        sort: [
+          { isPinned: "desc" },
+          { order: "asc" }
+        ]
+      });
       const accessibleBookmarks = allBookmarks?.filter((bookmark) => {
-        if (bookmark.createdBy?.id === userId) {
+        if (bookmark.creatorId === userId) {
           return true;
         }
         if (bookmark.isPublic) {
@@ -819,119 +866,140 @@ const bookmarkService = ({ strapi }) => ({
       throw error;
     }
   },
+  /**
+   * Create a new bookmark
+   * @param name - Bookmark name
+   * @param path - URL path
+   * @param query - Query string
+   * @param emoji - Emoji icon
+   * @param description - Description
+   * @param userId - Creator's documentId
+   * @param sharedWithRoles - Array of role documentIds
+   * @param sharedWithUsers - Array of user documentIds
+   * @param isPublic - Public visibility
+   * @returns Created bookmark
+   */
   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 bookmarks = await strapi.documents(BOOKMARK_UID).findMany({
+        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
-          }
+      const bookmark = await strapi.documents(BOOKMARK_UID).create({
+        data: {
+          name,
+          path,
+          query: query || "",
+          emoji: emoji || "bookmark",
+          description,
+          isPinned: false,
+          order: (maxOrder || 0) + 1,
+          creatorId: userId,
+          // Store as string field, not relation
+          updaterId: 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) {
+  /**
+   * Update an existing bookmark
+   * @param documentId - Bookmark's documentId
+   * @param data - Update data
+   * @param userId - Editor's documentId
+   * @returns Updated bookmark
+   */
+  async update(documentId, data, userId) {
     try {
-      const existingBookmark = await strapi.entityService.findOne(
-        "plugin::magic-mark.bookmark",
-        id,
-        {
-          populate: ["createdBy"]
-        }
-      );
-      if (!existingBookmark || existingBookmark.createdBy?.id !== userId) {
+      const existingBookmark = await strapi.documents(BOOKMARK_UID).findOne({
+        documentId
+      });
+      if (!existingBookmark || existingBookmark.creatorId !== 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
-          }
+      const bookmark = await strapi.documents(BOOKMARK_UID).update({
+        documentId,
+        data: {
+          name: data.name,
+          path: data.path,
+          query: data.query || "",
+          emoji: data.emoji || "bookmark",
+          description: data.description,
+          isPinned: data.isPinned,
+          order: data.order,
+          sharedWithRoles: data.sharedWithRoles,
+          sharedWithUsers: data.sharedWithUsers,
+          isPublic: data.isPublic,
+          updaterId: userId
+          // Store as string field
         }
-      );
+      });
       return bookmark;
     } catch (error) {
       strapi.log.error("[magic-mark] Error updating bookmark:", error);
       throw error;
     }
   },
-  async delete(id) {
+  /**
+   * Delete a bookmark
+   * @param documentId - Bookmark's documentId
+   * @returns Deleted bookmark
+   */
+  async delete(documentId) {
     try {
-      return await strapi.entityService.delete(
-        "plugin::magic-mark.bookmark",
-        id
-      );
+      return await strapi.documents(BOOKMARK_UID).delete({
+        documentId
+      });
     } catch (error) {
       strapi.log.error("[magic-mark] Error deleting bookmark:", error);
       throw error;
     }
   },
-  async pin(id, isPinned, userId) {
+  /**
+   * Pin or unpin a bookmark
+   * @param documentId - Bookmark's documentId
+   * @param isPinned - Pin status
+   * @param userId - Editor's documentId
+   * @returns Updated bookmark
+   */
+  async pin(documentId, isPinned, userId) {
     try {
-      const bookmark = await strapi.entityService.update(
-        "plugin::magic-mark.bookmark",
-        id,
-        {
-          data: {
-            isPinned,
-            updatedBy: userId
-          }
+      const bookmark = await strapi.documents(BOOKMARK_UID).update({
+        documentId,
+        data: {
+          isPinned,
+          updaterId: userId
         }
-      );
+      });
       return bookmark;
     } catch (error) {
       strapi.log.error("[magic-mark] Error pinning bookmark:", error);
       throw error;
     }
   },
+  /**
+   * Reorder bookmarks
+   * @param bookmarkIds - Array of bookmark documentIds in new order
+   * @param userId - Editor's documentId
+   * @returns Updated bookmarks
+   */
   async reorder(bookmarkIds, userId) {
     try {
       const updates = bookmarkIds.map(
-        (id, index2) => strapi.entityService.update(
-          "plugin::magic-mark.bookmark",
-          id,
-          {
-            data: {
-              order: index2,
-              updatedBy: userId
-            }
+        (documentId, index2) => strapi.documents(BOOKMARK_UID).update({
+          documentId,
+          data: {
+            order: index2,
+            updaterId: userId
           }
-        )
+        })
       );
       return Promise.all(updates);
     } catch (error) {
@@ -939,6 +1007,11 @@ const bookmarkService = ({ strapi }) => ({
       throw error;
     }
   },
+  /**
+   * Validate URL format
+   * @param url - URL to validate
+   * @returns True if valid
+   */
   validateUrl(url) {
     try {
       new URL(url);
@@ -948,6 +1021,13 @@ const bookmarkService = ({ strapi }) => ({
     }
   }
 });
+let pluginVersion = "2.0.0";
+try {
+  const pkgPath = join(__dirname, "../../../package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  pluginVersion = pkg.version || "2.0.0";
+} catch (e) {
+}
 const LICENSE_SERVER_URL = "https://magicapi.fitlex.me";
 const licenseGuardService = ({ strapi }) => ({
   /**
@@ -1013,7 +1093,8 @@ const licenseGuardService = ({ strapi }) => ({
    * Get user agent (server context)
    */
   getUserAgent() {
-    return `Strapi/${strapi.config.get("info.strapi") || "5.0.0"} Node/${process.version} ${os.platform()}/${os.release()}`;
+    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
@@ -1044,14 +1125,14 @@ const licenseGuardService = ({ strapi }) => ({
       });
       const data = await response.json();
       if (data.success) {
-        strapi.log.info("✅ License created successfully:", data.data.licenseKey);
+        strapi.log.info("[SUCCESS] License created successfully:", data.data.licenseKey);
         return data.data;
       } else {
-        strapi.log.error("❌ License creation failed:", data);
+        strapi.log.error("[ERROR] License creation failed:", data);
         return null;
       }
     } catch (error) {
-      strapi.log.error("❌ Error creating license:", error);
+      strapi.log.error("[ERROR] Error creating license:", error);
       return null;
     }
   },
@@ -1080,7 +1161,7 @@ const licenseGuardService = ({ strapi }) => ({
       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)}...)`);
+        strapi.log.info(`[SUCCESS] License verified online: ${statusInfo} (Key: ${licenseKey?.substring(0, 8)}...)`);
         if (isValid) {
           const pluginStore = strapi.store({
             type: "plugin",
@@ -1093,16 +1174,16 @@ const licenseGuardService = ({ strapi }) => ({
           data: data.data
         };
       } else {
-        strapi.log.warn(`⚠️ License verification failed: ${data.message || "Unknown error"} (Key: ${licenseKey?.substring(0, 8)}...)`);
+        strapi.log.warn(`[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`);
+        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 verifying license: ${error.message} (Key: ${licenseKey?.substring(0, 8)}...)`);
+      strapi.log.error(`[ERROR] Error verifying license: ${error.message} (Key: ${licenseKey?.substring(0, 8)}...)`);
       return { valid: false, data: null };
     }
   },
@@ -1125,10 +1206,10 @@ const licenseGuardService = ({ strapi }) => ({
       });
       const data = await response.json();
       if (data.success) {
-        strapi.log.debug(`📡 License ping successful: ${data.data?.isActive ? "ACTIVE" : "INACTIVE"} (Key: ${licenseKey?.substring(0, 8)}...)`);
+        strapi.log.debug(`[PING] 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)}...)`);
+        strapi.log.debug(`[WARN] License ping failed: ${data.message || "Unknown error"} (Key: ${licenseKey?.substring(0, 8)}...)`);
         return null;
       }
     } catch (error) {
@@ -1149,7 +1230,7 @@ const licenseGuardService = ({ strapi }) => ({
       }
       return null;
     } catch (error) {
-      strapi.log.error("❌ Error fetching license by key:", error);
+      strapi.log.error("[ERROR] Error fetching license by key:", error);
       return null;
     }
   },
@@ -1166,7 +1247,7 @@ const licenseGuardService = ({ strapi }) => ({
       }
       return null;
     } catch (error) {
-      strapi.log.error("❌ Error fetching online stats:", error);
+      strapi.log.error("[ERROR] Error fetching online stats:", error);
       return null;
     }
   },
@@ -1179,7 +1260,7 @@ const licenseGuardService = ({ strapi }) => ({
     const pingInterval = setInterval(async () => {
       await this.pingLicense(licenseKey);
     }, intervalMs);
-    strapi.log.info(`📡 Started pinging license every ${intervalMinutes} minutes`);
+    strapi.log.info(`[PING] Started pinging license every ${intervalMinutes} minutes`);
     return pingInterval;
   },
   /**
@@ -1188,7 +1269,7 @@ const licenseGuardService = ({ strapi }) => ({
    */
   async initialize() {
     try {
-      strapi.log.info("🔐 Initializing License Guard...");
+      strapi.log.info("[LICENSE] Initializing License Guard...");
       const pluginStore = strapi.store({
         type: "plugin",
         name: "magic-mark"
@@ -1204,29 +1285,29 @@ const licenseGuardService = ({ strapi }) => ({
         withinGracePeriod = hoursSinceValidation < gracePeriodHours;
       }
       strapi.log.info("──────────────────────────────────────────────────────────");
-      strapi.log.info(`📦 Plugin Store Check:`);
+      strapi.log.info(`[STORE] Plugin Store Check:`);
       if (licenseKey) {
-        strapi.log.info(`   ✅ License Key found: ${licenseKey}`);
-        strapi.log.info(`   🔑 Key (short): ${licenseKey.substring(0, 8)}...`);
+        strapi.log.info(`   [OK] License Key found: ${licenseKey}`);
+        strapi.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));
-          strapi.log.info(`   🕐 Last validated: ${hoursAgo}h ago (Grace: ${withinGracePeriod ? "ACTIVE" : "EXPIRED"})`);
+          strapi.log.info(`   [TIME] Last validated: ${hoursAgo}h ago (Grace: ${withinGracePeriod ? "ACTIVE" : "EXPIRED"})`);
         } else {
-          strapi.log.info(`   🕐 Last validated: Never (Grace: ACTIVE for first ${gracePeriodHours}h)`);
+          strapi.log.info(`   [TIME] Last validated: Never (Grace: ACTIVE for first ${gracePeriodHours}h)`);
         }
       } else {
-        strapi.log.info(`   ❌ No license key stored`);
+        strapi.log.info(`   [NONE] No license key stored`);
       }
       strapi.log.info("──────────────────────────────────────────────────────────");
       if (licenseKey) {
-        strapi.log.info("📄 Verifying stored license key...");
+        strapi.log.info("[VERIFY] 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)");
+            strapi.log.info("[SUCCESS] License accepted (offline mode / grace period)");
           } else {
-            strapi.log.info("✅ License is valid and active");
+            strapi.log.info("[SUCCESS] License is valid and active");
           }
           const pingInterval = this.startPinging(licenseKey, 15);
           strapi.licenseGuard = {
@@ -1236,17 +1317,17 @@ const licenseGuardService = ({ strapi }) => ({
           };
           return { valid: true, data: verification.data };
         } else {
-          strapi.log.warn("⚠️ Stored license is invalid or expired");
+          strapi.log.warn("[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.");
+      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 initializing license guard:", error);
+      strapi.log.error("[ERROR] Error initializing license guard:", error);
       return { valid: false, error: error.message };
     }
   },
@@ -1255,7 +1336,7 @@ const licenseGuardService = ({ strapi }) => ({
    */
   async storeLicenseKey(licenseKey) {
     try {
-      strapi.log.info(`🔐 Storing license key: ${licenseKey}`);
+      strapi.log.info(`[STORE] Storing license key: ${licenseKey}`);
       const pluginStore = strapi.store({
         type: "plugin",
         name: "magic-mark"
@@ -1264,14 +1345,14 @@ const licenseGuardService = ({ strapi }) => ({
       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");
+        strapi.log.info("[SUCCESS] License key stored and verified successfully");
         return true;
       } else {
-        strapi.log.error("❌ License key storage verification failed");
+        strapi.log.error("[ERROR] License key storage verification failed");
         return false;
       }
     } catch (error) {
-      strapi.log.error("❌ Error storing license key:", error);
+      strapi.log.error("[ERROR] Error storing license key:", error);
       return false;
     }
   },
@@ -1282,7 +1363,7 @@ const licenseGuardService = ({ strapi }) => ({
     const licenseGuard = strapi.licenseGuard;
     if (licenseGuard && licenseGuard.pingInterval) {
       clearInterval(licenseGuard.pingInterval);
-      strapi.log.info("🛑 License pinging stopped");
+      strapi.log.info("[STOP] License pinging stopped");
     }
   }
 });