strapi-plugin-magic-sessionmanager 3.6.0 → 4.0.0

package/dist/server/index.mjs

@@ -4,7 +4,7 @@ function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
 var register$1 = async ({ strapi: strapi2 }) => {
-  strapi2.log.info("[magic-sessionmanager] 🚀 Plugin registration starting...");
+  strapi2.log.info("[magic-sessionmanager] [START] Plugin registration starting...");
   try {
     const userCT = strapi2.contentType("plugin::users-permissions.user");
     if (!userCT) {
@@ -13,11 +13,11 @@ var register$1 = async ({ strapi: strapi2 }) => {
     }
     if (userCT.attributes && userCT.attributes.sessions) {
       delete userCT.attributes.sessions;
-      strapi2.log.info("[magic-sessionmanager] ✅ Removed sessions field from User content type");
+      strapi2.log.info("[magic-sessionmanager] [SUCCESS] Removed sessions field from User content type");
     }
-    strapi2.log.info("[magic-sessionmanager] ✅ Plugin registered successfully");
+    strapi2.log.info("[magic-sessionmanager] [SUCCESS] Plugin registered successfully");
   } catch (err) {
-    strapi2.log.error("[magic-sessionmanager] ❌ Registration error:", err);
+    strapi2.log.error("[magic-sessionmanager] [ERROR] Registration error:", err);
   }
 };
 const getClientIp$1 = (ctx) => {
@@ -94,7 +94,7 @@ function getEncryptionKey() {
   }
   const strapiKeys = process.env.APP_KEYS || process.env.API_TOKEN_SALT || "default-insecure-key";
   const key = crypto$1.createHash("sha256").update(strapiKeys).digest();
-  console.warn("[magic-sessionmanager/encryption] ⚠️  No SESSION_ENCRYPTION_KEY found. Using fallback (not recommended for production).");
+  console.warn("[magic-sessionmanager/encryption] [WARNING]  No SESSION_ENCRYPTION_KEY found. Using fallback (not recommended for production).");
   console.warn("[magic-sessionmanager/encryption] Set SESSION_ENCRYPTION_KEY in .env for better security.");
   return key;
 }
@@ -145,20 +145,21 @@ var encryption = {
   decryptToken: decryptToken$3,
   generateSessionId: generateSessionId$1
 };
+const SESSION_UID$3 = "plugin::magic-sessionmanager.session";
 var lastSeen = ({ strapi: strapi2, sessionService }) => {
   return async (ctx, next) => {
     if (ctx.state.user && ctx.state.user.id) {
       try {
         const userId = ctx.state.user.id;
-        const activeSessions = await strapi2.entityService.findMany("plugin::magic-sessionmanager.session", {
+        const activeSessions = await strapi2.documents(SESSION_UID$3).findMany({
           filters: {
-            user: { id: userId },
+            user: { documentId: userId },
             isActive: true
           },
           limit: 1
         });
         if (!activeSessions || activeSessions.length === 0) {
-          strapi2.log.info(`[magic-sessionmanager] 🚫 Blocked request - User ${userId} has no active sessions`);
+          strapi2.log.info(`[magic-sessionmanager] [BLOCKED] Blocked request - User ${userId} has no active sessions`);
           return ctx.unauthorized("All sessions have been terminated. Please login again.");
         }
       } catch (err) {
@@ -182,15 +183,16 @@ var lastSeen = ({ strapi: strapi2, sessionService }) => {
 };
 const getClientIp = getClientIp_1;
 const { encryptToken: encryptToken$1, decryptToken: decryptToken$2 } = encryption;
+const SESSION_UID$2 = "plugin::magic-sessionmanager.session";
 var bootstrap$1 = async ({ strapi: strapi2 }) => {
-  strapi2.log.info("[magic-sessionmanager] 🚀 Bootstrap starting...");
+  strapi2.log.info("[magic-sessionmanager] [START] Bootstrap starting...");
   try {
     const licenseGuardService = strapi2.plugin("magic-sessionmanager").service("license-guard");
     setTimeout(async () => {
       const licenseStatus = await licenseGuardService.initialize();
       if (!licenseStatus.valid) {
         strapi2.log.error("╔════════════════════════════════════════════════════════════════╗");
-        strapi2.log.error("║  ❌ SESSION MANAGER - NO VALID LICENSE                         ║");
+        strapi2.log.error("║  [ERROR] SESSION MANAGER - NO VALID LICENSE                         ║");
         strapi2.log.error("║                                                                ║");
         strapi2.log.error("║  This plugin requires a valid license to operate.             ║");
         strapi2.log.error("║  Please activate your license via Admin UI:                   ║");
@@ -206,7 +208,7 @@ var bootstrap$1 = async ({ strapi: strapi2 }) => {
         });
         const storedKey = await pluginStore.get({ key: "licenseKey" });
         strapi2.log.info("╔════════════════════════════════════════════════════════════════╗");
-        strapi2.log.info("║  ✅ SESSION MANAGER LICENSE ACTIVE                             ║");
+        strapi2.log.info("║  [SUCCESS] SESSION MANAGER LICENSE ACTIVE                             ║");
         strapi2.log.info("║                                                                ║");
         if (licenseStatus.data) {
           strapi2.log.info(`║  License: ${licenseStatus.data.licenseKey}`.padEnd(66) + "║");
@@ -217,7 +219,7 @@ var bootstrap$1 = async ({ strapi: strapi2 }) => {
           strapi2.log.info(`║  Status: Grace Period Active`.padEnd(66) + "║");
         }
         strapi2.log.info("║                                                                ║");
-        strapi2.log.info("║  🔄 Auto-pinging every 15 minutes                              ║");
+        strapi2.log.info("║  [RELOAD] Auto-pinging every 15 minutes                              ║");
         strapi2.log.info("╚════════════════════════════════════════════════════════════════╝");
       }
     }, 3e3);
@@ -233,7 +235,7 @@ var bootstrap$1 = async ({ strapi: strapi2 }) => {
         strapi2.log.error("[magic-sessionmanager] Periodic cleanup error:", err);
       }
     }, cleanupInterval);
-    strapi2.log.info("[magic-sessionmanager] ⏰ Periodic cleanup scheduled (every 30 minutes)");
+    strapi2.log.info("[magic-sessionmanager] [TIME] Periodic cleanup scheduled (every 30 minutes)");
     if (!strapi2.sessionManagerIntervals) {
       strapi2.sessionManagerIntervals = {};
     }
@@ -249,7 +251,7 @@ var bootstrap$1 = async ({ strapi: strapi2 }) => {
             ctx.body = { message: "Logged out successfully" };
             return;
           }
-          const allSessions = await strapi2.entityService.findMany("plugin::magic-sessionmanager.session", {
+          const allSessions = await strapi2.documents(SESSION_UID$2).findMany({
             filters: {
               isActive: true
             }
@@ -264,8 +266,8 @@ var bootstrap$1 = async ({ strapi: strapi2 }) => {
             }
           });
           if (matchingSession) {
-            await sessionService.terminateSession({ sessionId: matchingSession.id });
-            strapi2.log.info(`[magic-sessionmanager] 🚪 Logout via /api/auth/logout - Session ${matchingSession.id} terminated`);
+            await sessionService.terminateSession({ sessionId: matchingSession.documentId });
+            strapi2.log.info(`[magic-sessionmanager] [LOGOUT] Logout via /api/auth/logout - Session ${matchingSession.documentId} terminated`);
           }
           ctx.status = 200;
           ctx.body = { message: "Logged out successfully" };
@@ -279,7 +281,7 @@ var bootstrap$1 = async ({ strapi: strapi2 }) => {
         auth: false
       }
     }]);
-    strapi2.log.info("[magic-sessionmanager] ✅ /api/auth/logout route registered");
+    strapi2.log.info("[magic-sessionmanager] [SUCCESS] /api/auth/logout route registered");
     strapi2.server.use(async (ctx, next) => {
       await next();
       const isAuthLocal = ctx.path === "/api/auth/local" && ctx.method === "POST";
@@ -289,7 +291,7 @@ var bootstrap$1 = async ({ strapi: strapi2 }) => {
           const user = ctx.body.user;
           const ip = getClientIp(ctx);
           const userAgent = ctx.request.headers?.["user-agent"] || ctx.request.header?.["user-agent"] || "unknown";
-          strapi2.log.info(`[magic-sessionmanager] 🔍 Login detected! User: ${user.id} (${user.email || user.username}) from IP: ${ip}`);
+          strapi2.log.info(`[magic-sessionmanager] [CHECK] Login detected! User: ${user.id} (${user.email || user.username}) from IP: ${ip}`);
           const config2 = strapi2.config.get("plugin::magic-sessionmanager") || {};
           let shouldBlock = false;
           let blockReason = "";
@@ -331,7 +333,7 @@ var bootstrap$1 = async ({ strapi: strapi2 }) => {
             }
           }
           if (shouldBlock) {
-            strapi2.log.warn(`[magic-sessionmanager] 🚫 Blocking login: ${blockReason}`);
+            strapi2.log.warn(`[magic-sessionmanager] [BLOCKED] Blocking login: ${blockReason}`);
             ctx.status = 403;
             ctx.body = {
               error: {
@@ -351,7 +353,7 @@ var bootstrap$1 = async ({ strapi: strapi2 }) => {
             refreshToken: ctx.body.refreshToken
             // Store Refresh Token (encrypted) if exists
           });
-          strapi2.log.info(`[magic-sessionmanager] ✅ Session created for user ${user.id} (IP: ${ip})`);
+          strapi2.log.info(`[magic-sessionmanager] [SUCCESS] Session created for user ${user.id} (IP: ${ip})`);
           if (geoData && (config2.enableEmailAlerts || config2.enableWebhooks)) {
             try {
               const notificationService = strapi2.plugin("magic-sessionmanager").service("notifications");
@@ -389,18 +391,18 @@ var bootstrap$1 = async ({ strapi: strapi2 }) => {
             }
           }
         } catch (err) {
-          strapi2.log.error("[magic-sessionmanager] ❌ Error creating session:", err);
+          strapi2.log.error("[magic-sessionmanager] [ERROR] Error creating session:", err);
         }
       }
     });
-    strapi2.log.info("[magic-sessionmanager] ✅ Login/Logout interceptor middleware mounted");
+    strapi2.log.info("[magic-sessionmanager] [SUCCESS] Login/Logout interceptor middleware mounted");
     strapi2.server.use(async (ctx, next) => {
       const isRefreshToken = ctx.path === "/api/auth/refresh" && ctx.method === "POST";
       if (isRefreshToken) {
         try {
           const refreshToken = ctx.request.body?.refreshToken;
           if (refreshToken) {
-            const allSessions = await strapi2.entityService.findMany("plugin::magic-sessionmanager.session", {
+            const allSessions = await strapi2.documents(SESSION_UID$2).findMany({
               filters: {
                 isActive: true
               }
@@ -415,7 +417,7 @@ var bootstrap$1 = async ({ strapi: strapi2 }) => {
               }
             });
             if (!matchingSession) {
-              strapi2.log.warn("[magic-sessionmanager] 🚫 Blocked refresh token request - no active session");
+              strapi2.log.warn("[magic-sessionmanager] [BLOCKED] Blocked refresh token request - no active session");
               ctx.status = 401;
               ctx.body = {
                 error: {
@@ -426,7 +428,7 @@ var bootstrap$1 = async ({ strapi: strapi2 }) => {
               };
               return;
             }
-            strapi2.log.info(`[magic-sessionmanager] ✅ Refresh token allowed for session ${matchingSession.id}`);
+            strapi2.log.info(`[magic-sessionmanager] [SUCCESS] Refresh token allowed for session ${matchingSession.documentId}`);
           }
         } catch (err) {
           strapi2.log.error("[magic-sessionmanager] Error checking refresh token:", err);
@@ -439,7 +441,7 @@ var bootstrap$1 = async ({ strapi: strapi2 }) => {
           const newAccessToken = ctx.body.jwt;
           const newRefreshToken = ctx.body.refreshToken;
           if (oldRefreshToken) {
-            const allSessions = await strapi2.entityService.findMany("plugin::magic-sessionmanager.session", {
+            const allSessions = await strapi2.documents(SESSION_UID$2).findMany({
               filters: {
                 isActive: true
               }
@@ -456,14 +458,15 @@ var bootstrap$1 = async ({ strapi: strapi2 }) => {
             if (matchingSession) {
               const encryptedToken = newAccessToken ? encryptToken$1(newAccessToken) : matchingSession.token;
               const encryptedRefreshToken = newRefreshToken ? encryptToken$1(newRefreshToken) : matchingSession.refreshToken;
-              await strapi2.entityService.update("plugin::magic-sessionmanager.session", matchingSession.id, {
+              await strapi2.documents(SESSION_UID$2).update({
+                documentId: matchingSession.documentId,
                 data: {
                   token: encryptedToken,
                   refreshToken: encryptedRefreshToken,
                   lastActive: /* @__PURE__ */ new Date()
                 }
               });
-              strapi2.log.info(`[magic-sessionmanager] 🔄 Tokens refreshed for session ${matchingSession.id}`);
+              strapi2.log.info(`[magic-sessionmanager] [REFRESH] Tokens refreshed for session ${matchingSession.documentId}`);
             }
           }
         } catch (err) {
@@ -471,15 +474,15 @@ var bootstrap$1 = async ({ strapi: strapi2 }) => {
         }
       }
     });
-    strapi2.log.info("[magic-sessionmanager] ✅ Refresh Token interceptor middleware mounted");
+    strapi2.log.info("[magic-sessionmanager] [SUCCESS] Refresh Token interceptor middleware mounted");
     strapi2.server.use(
       lastSeen({ strapi: strapi2, sessionService })
     );
-    strapi2.log.info("[magic-sessionmanager] ✅ LastSeen middleware mounted");
-    strapi2.log.info("[magic-sessionmanager] ✅ Bootstrap complete");
-    strapi2.log.info("[magic-sessionmanager] 🎉 Session Manager ready! Sessions stored in plugin::magic-sessionmanager.session");
+    strapi2.log.info("[magic-sessionmanager] [SUCCESS] LastSeen middleware mounted");
+    strapi2.log.info("[magic-sessionmanager] [SUCCESS] Bootstrap complete");
+    strapi2.log.info("[magic-sessionmanager] [READY] Session Manager ready! Sessions stored in plugin::magic-sessionmanager.session");
   } catch (err) {
-    strapi2.log.error("[magic-sessionmanager] ❌ Bootstrap error:", err);
+    strapi2.log.error("[magic-sessionmanager] [ERROR] Bootstrap error:", err);
   }
 };
 var destroy$1 = async ({ strapi: strapi2 }) => {
@@ -491,7 +494,7 @@ var destroy$1 = async ({ strapi: strapi2 }) => {
     clearInterval(strapi2.sessionManagerIntervals.cleanup);
     strapi2.log.info("[magic-sessionmanager] 🛑 Session cleanup interval stopped");
   }
-  strapi2.log.info("[magic-sessionmanager] ✅ Plugin cleanup completed");
+  strapi2.log.info("[magic-sessionmanager] [SUCCESS] Plugin cleanup completed");
 };
 var config$1 = {
   default: {
@@ -799,6 +802,8 @@ var routes$1 = {
   "content-api": contentApi
 };
 const { decryptToken: decryptToken$1 } = encryption;
+const SESSION_UID$1 = "plugin::magic-sessionmanager.session";
+const USER_UID = "plugin::users-permissions.user";
 var session$3 = {
   /**
    * Get ALL sessions (active + inactive) - Admin only
@@ -877,9 +882,9 @@ var session$3 = {
         return ctx.throw(401, "Unauthorized");
       }
       const sessionService = strapi.plugin("magic-sessionmanager").service("session");
-      const sessions = await strapi.entityService.findMany("plugin::magic-sessionmanager.session", {
+      const sessions = await strapi.documents(SESSION_UID$1).findMany({
         filters: {
-          user: { id: userId },
+          user: { documentId: userId },
           isActive: true
         }
       });
@@ -893,8 +898,8 @@ var session$3 = {
         }
       });
       if (matchingSession) {
-        await sessionService.terminateSession({ sessionId: matchingSession.id });
-        strapi.log.info(`[magic-sessionmanager] User ${userId} logged out (session ${matchingSession.id})`);
+        await sessionService.terminateSession({ sessionId: matchingSession.documentId });
+        strapi.log.info(`[magic-sessionmanager] User ${userId} logged out (session ${matchingSession.documentId})`);
       }
       ctx.body = {
         message: "Logged out successfully"
@@ -1054,12 +1059,13 @@ var session$3 = {
   async toggleUserBlock(ctx) {
     try {
       const { userId } = ctx.params;
-      const user = await strapi.entityService.findOne("plugin::users-permissions.user", userId);
+      const user = await strapi.documents(USER_UID).findOne({ documentId: userId });
       if (!user) {
         return ctx.throw(404, "User not found");
       }
       const newBlockedStatus = !user.blocked;
-      await strapi.entityService.update("plugin::users-permissions.user", userId, {
+      await strapi.documents(USER_UID).update({
+        documentId: userId,
         data: {
           blocked: newBlockedStatus
         }
@@ -1253,16 +1259,16 @@ var license$1 = ({ strapi: strapi2 }) => ({
       const licenseGuard2 = strapi2.plugin("magic-sessionmanager").service("license-guard");
       const verification = await licenseGuard2.verifyLicense(trimmedKey);
       if (!verification.valid) {
-        strapi2.log.warn(`[magic-sessionmanager] ⚠️ Invalid license key attempted: ${trimmedKey.substring(0, 8)}...`);
+        strapi2.log.warn(`[magic-sessionmanager] [WARNING] Invalid license key attempted: ${trimmedKey.substring(0, 8)}...`);
         return ctx.badRequest("Invalid or expired license key");
       }
       const license2 = await licenseGuard2.getLicenseByKey(trimmedKey);
       if (!license2) {
-        strapi2.log.warn(`[magic-sessionmanager] ⚠️ License not found in database: ${trimmedKey.substring(0, 8)}...`);
+        strapi2.log.warn(`[magic-sessionmanager] [WARNING] License not found in database: ${trimmedKey.substring(0, 8)}...`);
         return ctx.badRequest("License not found");
       }
       if (license2.email.toLowerCase() !== trimmedEmail) {
-        strapi2.log.warn(`[magic-sessionmanager] ⚠️ Email mismatch for license key: ${trimmedKey.substring(0, 8)}... (Attempted: ${trimmedEmail})`);
+        strapi2.log.warn(`[magic-sessionmanager] [WARNING] Email mismatch for license key: ${trimmedKey.substring(0, 8)}... (Attempted: ${trimmedEmail})`);
         return ctx.badRequest("Email address does not match this license key");
       }
       await licenseGuard2.storeLicenseKey(trimmedKey);
@@ -1272,7 +1278,7 @@ var license$1 = ({ strapi: strapi2 }) => ({
         pingInterval,
         data: verification.data
       };
-      strapi2.log.info(`[magic-sessionmanager] ✅ Existing license key validated and stored: ${trimmedKey.substring(0, 8)}... (Email: ${trimmedEmail})`);
+      strapi2.log.info(`[magic-sessionmanager] [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",
@@ -1394,6 +1400,7 @@ var controllers$1 = {
   settings
 };
 const { encryptToken, decryptToken, generateSessionId } = encryption;
+const SESSION_UID = "plugin::magic-sessionmanager.session";
 var session$1 = ({ strapi: strapi2 }) => ({
   /**
    * Create a new session record
@@ -1406,23 +1413,24 @@ var session$1 = ({ strapi: strapi2 }) => ({
       const sessionId = generateSessionId(userId);
       const encryptedToken = token ? encryptToken(token) : null;
       const encryptedRefreshToken = refreshToken ? encryptToken(refreshToken) : null;
-      const session2 = await strapi2.entityService.create("plugin::magic-sessionmanager.session", {
+      const session2 = await strapi2.documents(SESSION_UID).create({
         data: {
           user: userId,
+          // userId should be documentId (string)
           ipAddress: ip.substring(0, 45),
           userAgent: userAgent.substring(0, 500),
           loginTime: now,
           lastActive: now,
           isActive: true,
           token: encryptedToken,
-          // ✅ Encrypted Access Token
+          // [SUCCESS] Encrypted Access Token
           refreshToken: encryptedRefreshToken,
-          // ✅ Encrypted Refresh Token
+          // [SUCCESS] Encrypted Refresh Token
           sessionId
-          // ✅ Unique identifier
+          // [SUCCESS] Unique identifier
         }
       });
-      strapi2.log.info(`[magic-sessionmanager] ✅ Session ${session2.id} (${sessionId}) created for user ${userId}`);
+      strapi2.log.info(`[magic-sessionmanager] [SUCCESS] Session ${session2.documentId} (${sessionId}) created for user ${userId}`);
       return session2;
     } catch (err) {
       strapi2.log.error("[magic-sessionmanager] Error creating session:", err);
@@ -1438,7 +1446,8 @@ var session$1 = ({ strapi: strapi2 }) => ({
     try {
       const now = /* @__PURE__ */ new Date();
       if (sessionId) {
-        await strapi2.entityService.update("plugin::magic-sessionmanager.session", sessionId, {
+        await strapi2.documents(SESSION_UID).update({
+          documentId: sessionId,
           data: {
             isActive: false,
             logoutTime: now
@@ -1446,14 +1455,16 @@ var session$1 = ({ strapi: strapi2 }) => ({
         });
         strapi2.log.info(`[magic-sessionmanager] Session ${sessionId} terminated`);
       } else if (userId) {
-        const activeSessions = await strapi2.entityService.findMany("plugin::magic-sessionmanager.session", {
+        const activeSessions = await strapi2.documents(SESSION_UID).findMany({
           filters: {
-            user: { id: userId },
+            user: { documentId: userId },
+            // Deep filtering syntax
             isActive: true
           }
         });
         for (const session2 of activeSessions) {
-          await strapi2.entityService.update("plugin::magic-sessionmanager.session", session2.id, {
+          await strapi2.documents(SESSION_UID).update({
+            documentId: session2.documentId,
             data: {
               isActive: false,
               logoutTime: now
@@ -1473,7 +1484,7 @@ var session$1 = ({ strapi: strapi2 }) => ({
    */
   async getAllSessions() {
     try {
-      const sessions = await strapi2.entityService.findMany("plugin::magic-sessionmanager.session", {
+      const sessions = await strapi2.documents(SESSION_UID).findMany({
         populate: { user: { fields: ["id", "email", "username"] } },
         sort: { loginTime: "desc" },
         limit: 1e3
@@ -1505,7 +1516,7 @@ var session$1 = ({ strapi: strapi2 }) => ({
    */
   async getActiveSessions() {
     try {
-      const sessions = await strapi2.entityService.findMany("plugin::magic-sessionmanager.session", {
+      const sessions = await strapi2.documents(SESSION_UID).findMany({
         filters: { isActive: true },
         populate: { user: { fields: ["id", "email", "username"] } },
         sort: { loginTime: "desc" }
@@ -1537,8 +1548,8 @@ var session$1 = ({ strapi: strapi2 }) => ({
    */
   async getUserSessions(userId) {
     try {
-      const sessions = await strapi2.entityService.findMany("plugin::magic-sessionmanager.session", {
-        filters: { user: { id: userId } },
+      const sessions = await strapi2.documents(SESSION_UID).findMany({
+        filters: { user: { documentId: userId } },
         sort: { loginTime: "desc" }
       });
       const config2 = strapi2.config.get("plugin::magic-sessionmanager") || {};
@@ -1572,17 +1583,19 @@ var session$1 = ({ strapi: strapi2 }) => ({
       const config2 = strapi2.config.get("plugin::magic-sessionmanager") || {};
       const rateLimit = config2.lastSeenRateLimit || 3e4;
       if (sessionId) {
-        const session2 = await strapi2.entityService.findOne("plugin::magic-sessionmanager.session", sessionId);
+        const session2 = await strapi2.documents(SESSION_UID).findOne({ documentId: sessionId });
         if (session2 && session2.lastActive) {
           const lastActiveTime = new Date(session2.lastActive).getTime();
           const currentTime = now.getTime();
           if (currentTime - lastActiveTime > rateLimit) {
-            await strapi2.entityService.update("plugin::magic-sessionmanager.session", sessionId, {
+            await strapi2.documents(SESSION_UID).update({
+              documentId: sessionId,
               data: { lastActive: now }
             });
           }
         } else if (session2) {
-          await strapi2.entityService.update("plugin::magic-sessionmanager.session", sessionId, {
+          await strapi2.documents(SESSION_UID).update({
+            documentId: sessionId,
             data: { lastActive: now }
           });
         }
@@ -1601,22 +1614,23 @@ var session$1 = ({ strapi: strapi2 }) => ({
       const inactivityTimeout = config2.inactivityTimeout || 15 * 60 * 1e3;
       const now = /* @__PURE__ */ new Date();
       const cutoffTime = new Date(now.getTime() - inactivityTimeout);
-      strapi2.log.info(`[magic-sessionmanager] 🧹 Cleaning up sessions inactive since before ${cutoffTime.toISOString()}`);
-      const activeSessions = await strapi2.entityService.findMany("plugin::magic-sessionmanager.session", {
+      strapi2.log.info(`[magic-sessionmanager] [CLEANUP] Cleaning up sessions inactive since before ${cutoffTime.toISOString()}`);
+      const activeSessions = await strapi2.documents(SESSION_UID).findMany({
         filters: { isActive: true },
-        fields: ["id", "lastActive", "loginTime"]
+        fields: ["lastActive", "loginTime"]
       });
       let deactivatedCount = 0;
       for (const session2 of activeSessions) {
         const lastActiveTime = session2.lastActive ? new Date(session2.lastActive) : new Date(session2.loginTime);
         if (lastActiveTime < cutoffTime) {
-          await strapi2.entityService.update("plugin::magic-sessionmanager.session", session2.id, {
+          await strapi2.documents(SESSION_UID).update({
+            documentId: session2.documentId,
             data: { isActive: false }
           });
           deactivatedCount++;
         }
       }
-      strapi2.log.info(`[magic-sessionmanager] ✅ Cleanup complete: ${deactivatedCount} sessions deactivated`);
+      strapi2.log.info(`[magic-sessionmanager] [SUCCESS] Cleanup complete: ${deactivatedCount} sessions deactivated`);
       return deactivatedCount;
     } catch (err) {
       strapi2.log.error("[magic-sessionmanager] Error cleaning up inactive sessions:", err);
@@ -1631,8 +1645,8 @@ var session$1 = ({ strapi: strapi2 }) => ({
    */
   async deleteSession(sessionId) {
     try {
-      await strapi2.entityService.delete("plugin::magic-sessionmanager.session", sessionId);
-      strapi2.log.info(`[magic-sessionmanager] 🗑️ Session ${sessionId} permanently deleted`);
+      await strapi2.documents(SESSION_UID).delete({ documentId: sessionId });
+      strapi2.log.info(`[magic-sessionmanager] [DELETE] Session ${sessionId} permanently deleted`);
       return true;
     } catch (err) {
       strapi2.log.error("[magic-sessionmanager] Error deleting session:", err);
@@ -1646,17 +1660,16 @@ var session$1 = ({ strapi: strapi2 }) => ({
    */
   async deleteInactiveSessions() {
     try {
-      strapi2.log.info("[magic-sessionmanager] 🗑️ Deleting all inactive sessions...");
-      const inactiveSessions = await strapi2.entityService.findMany("plugin::magic-sessionmanager.session", {
-        filters: { isActive: false },
-        fields: ["id"]
+      strapi2.log.info("[magic-sessionmanager] [DELETE] Deleting all inactive sessions...");
+      const inactiveSessions = await strapi2.documents(SESSION_UID).findMany({
+        filters: { isActive: false }
       });
       let deletedCount = 0;
       for (const session2 of inactiveSessions) {
-        await strapi2.entityService.delete("plugin::magic-sessionmanager.session", session2.id);
+        await strapi2.documents(SESSION_UID).delete({ documentId: session2.documentId });
         deletedCount++;
       }
-      strapi2.log.info(`[magic-sessionmanager] ✅ Deleted ${deletedCount} inactive sessions`);
+      strapi2.log.info(`[magic-sessionmanager] [SUCCESS] Deleted ${deletedCount} inactive sessions`);
       return deletedCount;
     } catch (err) {
       strapi2.log.error("[magic-sessionmanager] Error deleting inactive sessions:", err);
@@ -1664,8 +1677,13 @@ var session$1 = ({ strapi: strapi2 }) => ({
     }
   }
 });
+const version = "3.7.0";
+const require$$2 = {
+  version
+};
 const crypto = require$$0$1;
 const os = require$$1;
+const pluginPkg = require$$2;
 const LICENSE_SERVER_URL = "https://magicapi.fitlex.me";
 var licenseGuard$1 = ({ strapi: strapi2 }) => ({
   /**
@@ -1720,7 +1738,9 @@ var licenseGuard$1 = ({ strapi: strapi2 }) => ({
     }
   },
   getUserAgent() {
-    return `Strapi/${strapi2.config.get("info.strapi") || "5.0.0"} Node/${process.version} ${os.platform()}/${os.release()}`;
+    const pluginVersion = pluginPkg.version;
+    const strapiVersion = strapi2.config.get("info.strapi") || "5.0.0";
+    return `MagicSessionManager/${pluginVersion} Strapi/${strapiVersion} Node/${process.version} ${os.platform()}/${os.release()}`;
   },
   async createLicense({ email, firstName, lastName }) {
     try {
@@ -1746,14 +1766,14 @@ var licenseGuard$1 = ({ strapi: strapi2 }) => ({
       });
       const data = await response.json();
       if (data.success) {
-        strapi2.log.info("[magic-sessionmanager] ✅ License created:", data.data.licenseKey);
+        strapi2.log.info("[magic-sessionmanager] [SUCCESS] License created:", data.data.licenseKey);
         return data.data;
       } else {
-        strapi2.log.error("[magic-sessionmanager] ❌ License creation failed:", data);
+        strapi2.log.error("[magic-sessionmanager] [ERROR] License creation failed:", data);
         return null;
       }
     } catch (error) {
-      strapi2.log.error("[magic-sessionmanager] ❌ Error creating license:", error);
+      strapi2.log.error("[magic-sessionmanager] [ERROR] Error creating license:", error);
       return null;
     }
   },
@@ -1838,10 +1858,10 @@ var licenseGuard$1 = ({ strapi: strapi2 }) => ({
       name: "magic-sessionmanager"
     });
     await pluginStore.set({ key: "licenseKey", value: licenseKey });
-    strapi2.log.info(`[magic-sessionmanager] ✅ License key stored: ${licenseKey.substring(0, 8)}...`);
+    strapi2.log.info(`[magic-sessionmanager] [SUCCESS] License key stored: ${licenseKey.substring(0, 8)}...`);
   },
   startPinging(licenseKey, intervalMinutes = 15) {
-    strapi2.log.info(`[magic-sessionmanager] ⏰ Starting license pings every ${intervalMinutes} minutes`);
+    strapi2.log.info(`[magic-sessionmanager] [TIME] Starting license pings every ${intervalMinutes} minutes`);
     this.pingLicense(licenseKey);
     const interval = setInterval(async () => {
       try {
@@ -1858,14 +1878,14 @@ var licenseGuard$1 = ({ strapi: strapi2 }) => ({
    */
   async initialize() {
     try {
-      strapi2.log.info("[magic-sessionmanager] 🔐 Initializing License Guard...");
+      strapi2.log.info("[magic-sessionmanager] [SECURE] Initializing License Guard...");
       const pluginStore = strapi2.store({
         type: "plugin",
         name: "magic-sessionmanager"
       });
       const licenseKey = await pluginStore.get({ key: "licenseKey" });
       if (!licenseKey) {
-        strapi2.log.info("[magic-sessionmanager] ℹ️ No license found - Running in demo mode");
+        strapi2.log.info("[magic-sessionmanager] [INFO] No license found - Running in demo mode");
         return {
           valid: false,
           demo: true,
@@ -1900,7 +1920,7 @@ var licenseGuard$1 = ({ strapi: strapi2 }) => ({
           gracePeriod: verification.gracePeriod || false
         };
       } else {
-        strapi2.log.error("[magic-sessionmanager] ❌ License validation failed");
+        strapi2.log.error("[magic-sessionmanager] [ERROR] License validation failed");
         return {
           valid: false,
           demo: true,
@@ -1909,7 +1929,7 @@ var licenseGuard$1 = ({ strapi: strapi2 }) => ({
         };
       }
     } catch (error) {
-      strapi2.log.error("[magic-sessionmanager] ❌ Error initializing License Guard:", error);
+      strapi2.log.error("[magic-sessionmanager] [ERROR] Error initializing License Guard:", error);
       return {
         valid: false,
         demo: true,
@@ -2022,9 +2042,11 @@ var geolocation$1 = ({ strapi: strapi2 }) => ({
   },
   /**
    * Get country flag emoji
+   * @param {string} countryCode - ISO 2-letter country code
+   * @returns {string} Flag emoji or empty string
    */
   getCountryFlag(countryCode) {
-    if (!countryCode) return "🏳️";
+    if (!countryCode) return "";
     const codePoints = countryCode.toUpperCase().split("").map((char) => 127397 + char.charCodeAt());
     return String.fromCodePoint(...codePoints);
   },
@@ -2036,7 +2058,7 @@ var geolocation$1 = ({ strapi: strapi2 }) => ({
       ip: ipAddress,
       country: "Unknown",
       country_code: "XX",
-      country_flag: "🌍",
+      country_flag: "[GEO]",
       city: "Unknown",
       region: "Unknown",
       timezone: "Unknown",
@@ -2141,9 +2163,9 @@ Login Details:
 Security: VPN={{reason.isVpn}}, Proxy={{reason.isProxy}}, Threat={{reason.isThreat}}, Score={{reason.securityScore}}/100`
       },
       newLocation: {
-        subject: "📍 New Location Login Detected",
-        html: `<h2>📍 New Location Login</h2><p>Account: {{user.email}}</p><p>Time: {{session.loginTime}}</p><p>Location: {{geo.city}}, {{geo.country}}</p><p>IP: {{session.ipAddress}}</p>`,
-        text: `📍 New Location Login
+        subject: "[LOCATION] New Location Login Detected",
+        html: `<h2>[LOCATION] New Location Login</h2><p>Account: {{user.email}}</p><p>Time: {{session.loginTime}}</p><p>Location: {{geo.city}}, {{geo.country}}</p><p>IP: {{session.ipAddress}}</p>`,
+        text: `[LOCATION] New Location Login
 
 Account: {{user.email}}
 Time: {{session.loginTime}}
@@ -2151,9 +2173,9 @@ Location: {{geo.city}}, {{geo.country}}
 IP: {{session.ipAddress}}`
       },
       vpnProxy: {
-        subject: "⚠️ VPN/Proxy Login Detected",
-        html: `<h2>⚠️ VPN/Proxy Detected</h2><p>Account: {{user.email}}</p><p>Time: {{session.loginTime}}</p><p>IP: {{session.ipAddress}}</p><p>VPN: {{reason.isVpn}}, Proxy: {{reason.isProxy}}</p>`,
-        text: `⚠️ VPN/Proxy Detected
+        subject: "[WARNING] VPN/Proxy Login Detected",
+        html: `<h2>[WARNING] VPN/Proxy Detected</h2><p>Account: {{user.email}}</p><p>Time: {{session.loginTime}}</p><p>IP: {{session.ipAddress}}</p><p>VPN: {{reason.isVpn}}, Proxy: {{reason.isProxy}}</p>`,
+        text: `[WARNING] VPN/Proxy Detected
 
 Account: {{user.email}}
 Time: {{session.loginTime}}
@@ -2307,7 +2329,7 @@ ${user.username || "N/A"}`, inline: true },
     };
     if (geoData) {
       embed.fields.push({
-        name: "📍 Location",
+        name: "[LOCATION] Location",
         value: `${geoData.country_flag} ${geoData.city}, ${geoData.country}`,
         inline: true
       });
@@ -2317,7 +2339,7 @@ ${user.username || "N/A"}`, inline: true },
         if (geoData.isProxy) warnings.push("Proxy");
         if (geoData.isThreat) warnings.push("Threat");
         embed.fields.push({
-          name: "⚠️ Security",
+          name: "[WARNING] Security",
           value: `${warnings.join(", ")} detected
 Score: ${geoData.securityScore}/100`,
           inline: true
@@ -2329,12 +2351,12 @@ Score: ${geoData.securityScore}/100`,
   getEventTitle(event) {
     const titles = {
       "login.suspicious": "🚨 Suspicious Login",
-      "login.new_location": "📍 New Location Login",
+      "login.new_location": "[LOCATION] New Location Login",
       "login.vpn": "🔴 VPN Login Detected",
       "login.threat": "⛔ Threat IP Login",
       "session.terminated": "🔴 Session Terminated"
     };
-    return titles[event] || "📊 Session Event";
+    return titles[event] || "[STATS] Session Event";
   },
   getEventColor(event) {
     const colors = {