strapi-plugin-magic-sessionmanager 3.7.0 → 4.0.1

package/dist/server/index.js

@@ -8,7 +8,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) {
@@ -17,11 +17,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) => {
@@ -98,7 +98,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;
 }
@@ -149,20 +149,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) {
+    if (ctx.state.user && ctx.state.user.documentId) {
       try {
-        const userId = ctx.state.user.id;
-        const activeSessions = await strapi2.entityService.findMany("plugin::magic-sessionmanager.session", {
+        const userId = ctx.state.user.documentId;
+        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) {
@@ -170,9 +171,9 @@ var lastSeen = ({ strapi: strapi2, sessionService }) => {
       }
     }
     await next();
-    if (ctx.state.user && ctx.state.user.id) {
+    if (ctx.state.user && ctx.state.user.documentId) {
       try {
-        const userId = ctx.state.user.id;
+        const userId = ctx.state.user.documentId;
         const sessionId = ctx.state.sessionId;
         await sessionService.touch({
           userId,
@@ -186,15 +187,17 @@ 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";
+const USER_UID$2 = "plugin::users-permissions.user";
 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:                   ║");
@@ -210,7 +213,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) + "║");
@@ -221,7 +224,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);
@@ -237,7 +240,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 = {};
     }
@@ -253,7 +256,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
             }
@@ -268,8 +271,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" };
@@ -283,7 +286,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";
@@ -293,7 +296,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.documentId || user.id} (${user.email || user.username}) from IP: ${ip}`);
           const config2 = strapi2.config.get("plugin::magic-sessionmanager") || {};
           let shouldBlock = false;
           let blockReason = "";
@@ -335,7 +338,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: {
@@ -346,8 +349,13 @@ var bootstrap$1 = async ({ strapi: strapi2 }) => {
             };
             return;
           }
+          let userDocId = user.documentId;
+          if (!userDocId && user.id) {
+            const fullUser = await strapi2.entityService.findOne(USER_UID$2, user.id);
+            userDocId = fullUser?.documentId || user.id;
+          }
           const newSession = await sessionService.createSession({
-            userId: user.id,
+            userId: userDocId,
             ip,
             userAgent,
             token: ctx.body.jwt,
@@ -355,7 +363,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 ${userDocId} (IP: ${ip})`);
           if (geoData && (config2.enableEmailAlerts || config2.enableWebhooks)) {
             try {
               const notificationService = strapi2.plugin("magic-sessionmanager").service("notifications");
@@ -393,18 +401,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
               }
@@ -419,7 +427,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: {
@@ -430,7 +438,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);
@@ -443,7 +451,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
               }
@@ -460,14 +468,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) {
@@ -475,17 +484,60 @@ 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");
+    await ensureContentApiPermissions(strapi2);
+    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);
   }
 };
+async function ensureContentApiPermissions(strapi2) {
+  try {
+    const authenticatedRole = await strapi2.query("plugin::users-permissions.role").findOne({
+      where: { type: "authenticated" }
+    });
+    if (!authenticatedRole) {
+      strapi2.log.warn("[magic-sessionmanager] Authenticated role not found - skipping permission setup");
+      return;
+    }
+    const requiredActions = [
+      "plugin::magic-sessionmanager.session.logout",
+      "plugin::magic-sessionmanager.session.logoutAll",
+      "plugin::magic-sessionmanager.session.getOwnSessions",
+      "plugin::magic-sessionmanager.session.getUserSessions"
+    ];
+    const existingPermissions = await strapi2.query("plugin::users-permissions.permission").findMany({
+      where: {
+        role: authenticatedRole.id,
+        action: { $in: requiredActions }
+      }
+    });
+    const existingActions = existingPermissions.map((p) => p.action);
+    const missingActions = requiredActions.filter((action) => !existingActions.includes(action));
+    if (missingActions.length === 0) {
+      strapi2.log.debug("[magic-sessionmanager] Content-API permissions already configured");
+      return;
+    }
+    for (const action of missingActions) {
+      await strapi2.query("plugin::users-permissions.permission").create({
+        data: {
+          action,
+          role: authenticatedRole.id
+        }
+      });
+      strapi2.log.info(`[magic-sessionmanager] [PERMISSION] Enabled ${action} for authenticated users`);
+    }
+    strapi2.log.info("[magic-sessionmanager] [SUCCESS] Content-API permissions configured for authenticated users");
+  } catch (err) {
+    strapi2.log.warn("[magic-sessionmanager] Could not auto-configure permissions:", err.message);
+    strapi2.log.warn("[magic-sessionmanager] Please manually enable plugin permissions in Settings > Users & Permissions > Roles > Authenticated");
+  }
+}
 var destroy$1 = async ({ strapi: strapi2 }) => {
   if (strapi2.licenseGuard && strapi2.licenseGuard.pingInterval) {
     clearInterval(strapi2.licenseGuard.pingInterval);
@@ -495,7 +547,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: {
@@ -638,13 +690,22 @@ var contentApi$1 = {
     // ============================================================
     // SESSION QUERIES
     // ============================================================
+    {
+      method: "GET",
+      path: "/my-sessions",
+      handler: "session.getOwnSessions",
+      config: {
+        auth: { strategies: ["users-permissions"] },
+        description: "Get own sessions (automatically uses authenticated user)"
+      }
+    },
     {
       method: "GET",
       path: "/user/:userId/sessions",
       handler: "session.getUserSessions",
       config: {
         auth: { strategies: ["users-permissions"] },
-        description: "Get own sessions (controller validates user can only see own sessions)"
+        description: "Get sessions by userId (validates user can only see own sessions)"
       }
     }
   ]
@@ -803,6 +864,8 @@ var routes$1 = {
   "content-api": contentApi
 };
 const { decryptToken: decryptToken$1 } = encryption;
+const SESSION_UID$1 = "plugin::magic-sessionmanager.session";
+const USER_UID$1 = "plugin::users-permissions.user";
 var session$3 = {
   /**
    * Get ALL sessions (active + inactive) - Admin only
@@ -842,6 +905,30 @@ var session$3 = {
       ctx.throw(500, "Error fetching active sessions");
     }
   },
+  /**
+   * Get own sessions (authenticated user)
+   * GET /api/magic-sessionmanager/my-sessions
+   * Automatically uses the authenticated user's documentId
+   */
+  async getOwnSessions(ctx) {
+    try {
+      const userId = ctx.state.user?.documentId;
+      if (!userId) {
+        return ctx.throw(401, "Unauthorized");
+      }
+      const sessionService = strapi.plugin("magic-sessionmanager").service("session");
+      const sessions = await sessionService.getUserSessions(userId);
+      ctx.body = {
+        data: sessions,
+        meta: {
+          count: sessions.length
+        }
+      };
+    } catch (err) {
+      strapi.log.error("[magic-sessionmanager] Error fetching own sessions:", err);
+      ctx.throw(500, "Error fetching sessions");
+    }
+  },
   /**
    * Get user's sessions
    * GET /magic-sessionmanager/user/:userId/sessions (Admin API)
@@ -852,9 +939,9 @@ var session$3 = {
     try {
       const { userId } = ctx.params;
       const isAdminRequest = ctx.state.userAbility || ctx.state.admin;
-      const requestingUserId = ctx.state.user?.id;
-      if (!isAdminRequest && requestingUserId && String(requestingUserId) !== String(userId)) {
-        strapi.log.warn(`[magic-sessionmanager] Security: User ${requestingUserId} tried to access sessions of user ${userId}`);
+      const requestingUserDocId = ctx.state.user?.documentId;
+      if (!isAdminRequest && requestingUserDocId && String(requestingUserDocId) !== String(userId)) {
+        strapi.log.warn(`[magic-sessionmanager] Security: User ${requestingUserDocId} tried to access sessions of user ${userId}`);
         return ctx.forbidden("You can only access your own sessions");
       }
       const sessionService = strapi.plugin("magic-sessionmanager").service("session");
@@ -875,15 +962,15 @@ var session$3 = {
    */
   async logout(ctx) {
     try {
-      const userId = ctx.state.user?.id;
+      const userId = ctx.state.user?.documentId;
       const token = ctx.request.headers.authorization?.replace("Bearer ", "");
       if (!userId) {
         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
         }
       });
@@ -897,8 +984,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"
@@ -914,7 +1001,7 @@ var session$3 = {
    */
   async logoutAll(ctx) {
     try {
-      const userId = ctx.state.user?.id;
+      const userId = ctx.state.user?.documentId;
       if (!userId) {
         return ctx.throw(401, "Unauthorized");
       }
@@ -1054,23 +1141,34 @@ var session$3 = {
   /**
    * Toggle user blocked status
    * POST /magic-sessionmanager/user/:userId/toggle-block
+   * Supports both numeric id (from Content Manager) and documentId
    */
   async toggleUserBlock(ctx) {
     try {
       const { userId } = ctx.params;
-      const user = await strapi.entityService.findOne("plugin::users-permissions.user", userId);
+      let userDocumentId = userId;
+      let user = null;
+      user = await strapi.documents(USER_UID$1).findOne({ documentId: userId });
+      if (!user && !isNaN(userId)) {
+        const numericUser = await strapi.entityService.findOne(USER_UID$1, parseInt(userId, 10));
+        if (numericUser) {
+          userDocumentId = numericUser.documentId;
+          user = numericUser;
+        }
+      }
       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$1).update({
+        documentId: userDocumentId,
         data: {
           blocked: newBlockedStatus
         }
       });
       if (newBlockedStatus) {
         const sessionService = strapi.plugin("magic-sessionmanager").service("session");
-        await sessionService.terminateSession({ userId });
+        await sessionService.terminateSession({ userId: userDocumentId });
       }
       ctx.body = {
         message: `User ${newBlockedStatus ? "blocked" : "unblocked"} successfully`,
@@ -1257,16 +1355,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);
@@ -1276,7 +1374,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",
@@ -1398,6 +1496,8 @@ var controllers$1 = {
   settings
 };
 const { encryptToken, decryptToken, generateSessionId } = encryption;
+const SESSION_UID = "plugin::magic-sessionmanager.session";
+const USER_UID = "plugin::users-permissions.user";
 var session$1 = ({ strapi: strapi2 }) => ({
   /**
    * Create a new session record
@@ -1410,23 +1510,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);
@@ -1435,6 +1536,7 @@ var session$1 = ({ strapi: strapi2 }) => ({
   },
   /**
    * Terminate a session or all sessions for a user
+   * Supports both numeric id (legacy) and documentId (Strapi v5)
    * @param {Object} params - { sessionId | userId }
    * @returns {Promise<void>}
    */
@@ -1442,7 +1544,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
@@ -1450,21 +1553,30 @@ 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", {
+        let userDocumentId = userId;
+        if (!isNaN(userId)) {
+          const user = await strapi2.entityService.findOne(USER_UID, parseInt(userId, 10));
+          if (user) {
+            userDocumentId = user.documentId;
+          }
+        }
+        const activeSessions = await strapi2.documents(SESSION_UID).findMany({
           filters: {
-            user: { id: userId },
+            user: { documentId: userDocumentId },
+            // 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
             }
           });
         }
-        strapi2.log.info(`[magic-sessionmanager] All sessions terminated for user ${userId}`);
+        strapi2.log.info(`[magic-sessionmanager] All sessions terminated for user ${userDocumentId}`);
       }
     } catch (err) {
       strapi2.log.error("[magic-sessionmanager] Error terminating session:", err);
@@ -1477,7 +1589,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
@@ -1509,7 +1621,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" }
@@ -1536,13 +1648,21 @@ var session$1 = ({ strapi: strapi2 }) => ({
   },
   /**
    * Get all sessions for a specific user
-   * @param {number} userId
+   * Supports both numeric id (legacy) and documentId (Strapi v5)
+   * @param {string|number} userId - User documentId or numeric id
    * @returns {Promise<Array>} User's sessions with accurate online status
    */
   async getUserSessions(userId) {
     try {
-      const sessions = await strapi2.entityService.findMany("plugin::magic-sessionmanager.session", {
-        filters: { user: { id: userId } },
+      let userDocumentId = userId;
+      if (!isNaN(userId)) {
+        const user = await strapi2.entityService.findOne(USER_UID, parseInt(userId, 10));
+        if (user) {
+          userDocumentId = user.documentId;
+        }
+      }
+      const sessions = await strapi2.documents(SESSION_UID).findMany({
+        filters: { user: { documentId: userDocumentId } },
         sort: { loginTime: "desc" }
       });
       const config2 = strapi2.config.get("plugin::magic-sessionmanager") || {};
@@ -1576,17 +1696,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 }
           });
         }
@@ -1605,22 +1727,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);
@@ -1635,8 +1758,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);
@@ -1650,17 +1773,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);
@@ -1668,8 +1790,13 @@ var session$1 = ({ strapi: strapi2 }) => ({
     }
   }
 });
+const version = "4.0.0";
+const require$$2 = {
+  version
+};
 const crypto = require$$0__default.default;
 const os = require$$1__default.default;
+const pluginPkg = require$$2;
 const LICENSE_SERVER_URL = "https://magicapi.fitlex.me";
 var licenseGuard$1 = ({ strapi: strapi2 }) => ({
   /**
@@ -1724,7 +1851,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 {
@@ -1750,14 +1879,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;
     }
   },
@@ -1842,10 +1971,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 {
@@ -1862,14 +1991,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,
@@ -1904,7 +2033,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,
@@ -1913,7 +2042,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,
@@ -2026,9 +2155,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);
   },
@@ -2040,7 +2171,7 @@ var geolocation$1 = ({ strapi: strapi2 }) => ({
       ip: ipAddress,
       country: "Unknown",
       country_code: "XX",
-      country_flag: "🌍",
+      country_flag: "[GEO]",
       city: "Unknown",
       region: "Unknown",
       timezone: "Unknown",
@@ -2090,12 +2221,12 @@ var notifications$1 = ({ strapi: strapi2 }) => ({
     strapi2.log.debug("[magic-sessionmanager/notifications] Using default fallback templates");
     return {
       suspiciousLogin: {
-        subject: "🚨 Suspicious Login Alert - Session Manager",
+        subject: "[ALERT] Suspicious Login Alert - Session Manager",
         html: `
 <html>
 <body style="font-family: Arial, sans-serif; line-height: 1.6; color: #333;">
   <div style="max-width: 600px; margin: 0 auto; padding: 20px; background-color: #f9fafb; border-radius: 10px;">
-    <h2 style="color: #dc2626;">🚨 Suspicious Login Detected</h2>
+    <h2 style="color: #dc2626;">[ALERT] Suspicious Login Detected</h2>
     <p>A potentially suspicious login was detected for your account.</p>
     
     <div style="background: white; padding: 15px; border-radius: 8px; margin: 20px 0;">
@@ -2130,7 +2261,7 @@ var notifications$1 = ({ strapi: strapi2 }) => ({
   </div>
 </body>
 </html>`,
-        text: `🚨 Suspicious Login Detected
+        text: `[ALERT] Suspicious Login Detected
 
 A potentially suspicious login was detected for your account.
 
@@ -2145,9 +2276,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}}
@@ -2155,9 +2286,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}}
@@ -2301,17 +2432,17 @@ VPN: {{reason.isVpn}}, Proxy: {{reason.isProxy}}`
       title: this.getEventTitle(event),
       color: this.getEventColor(event),
       fields: [
-        { name: "👤 User", value: `${user.email}
+        { name: "User", value: `${user.email}
 ${user.username || "N/A"}`, inline: true },
-        { name: "🌐 IP", value: session2.ipAddress, inline: true },
-        { name: "📅 Time", value: new Date(session2.loginTime).toLocaleString(), inline: false }
+        { name: "IP", value: session2.ipAddress, inline: true },
+        { name: "Time", value: new Date(session2.loginTime).toLocaleString(), inline: false }
       ],
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       footer: { text: "Magic Session Manager" }
     };
     if (geoData) {
       embed.fields.push({
-        name: "📍 Location",
+        name: "[LOCATION] Location",
         value: `${geoData.country_flag} ${geoData.city}, ${geoData.country}`,
         inline: true
       });
@@ -2321,7 +2452,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
@@ -2332,13 +2463,13 @@ Score: ${geoData.securityScore}/100`,
   },
   getEventTitle(event) {
     const titles = {
-      "login.suspicious": "🚨 Suspicious Login",
-      "login.new_location": "📍 New Location Login",
-      "login.vpn": "🔴 VPN Login Detected",
-      "login.threat": "⛔ Threat IP Login",
-      "session.terminated": "🔴 Session Terminated"
+      "login.suspicious": "[ALERT] Suspicious Login",
+      "login.new_location": "[LOCATION] New Location Login",
+      "login.vpn": "[WARNING] VPN Login Detected",
+      "login.threat": "[THREAT] Threat IP Login",
+      "session.terminated": "[INFO] Session Terminated"
     };
-    return titles[event] || "📊 Session Event";
+    return titles[event] || "[STATS] Session Event";
   },
   getEventColor(event) {
     const colors = {