magic-editor-x 1.0.0

package/dist/server/index.mjs

@@ -0,0 +1,2544 @@
+import require$$0 from "open-graph-scraper";
+import require$$1 from "fs";
+import require$$2$1 from "path";
+import require$$3 from "https";
+import require$$4 from "http";
+import require$$5 from "url";
+import require$$0$1 from "crypto";
+import require$$1$1 from "socket.io";
+import require$$2$2 from "yjs";
+import require$$1$2 from "os";
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var bootstrap$1 = async ({ strapi: strapi2 }) => {
+  try {
+    const contentTypes2 = [
+      "plugin::magic-editor-x.collab-session",
+      "plugin::magic-editor-x.document-snapshot",
+      "plugin::magic-editor-x.collab-permission"
+    ];
+    for (const contentType of contentTypes2) {
+      const exists = strapi2.contentType(contentType);
+      if (exists) {
+        strapi2.log.info(`[Magic Editor X] [SUCCESS] Content type registered: ${contentType}`);
+      } else {
+        strapi2.log.warn(`[Magic Editor X] [WARNING] Content type NOT found: ${contentType}`);
+      }
+    }
+    try {
+      const staleSessions = await strapi2.documents("plugin::magic-editor-x.collab-session").findMany({
+        limit: 1e3
+      });
+      if (staleSessions && staleSessions.length > 0) {
+        for (const session of staleSessions) {
+          await strapi2.documents("plugin::magic-editor-x.collab-session").delete({
+            documentId: session.documentId
+          });
+        }
+        strapi2.log.info(`[Magic Editor X] [CLEANUP] Cleaned up ${staleSessions.length} stale sessions`);
+      }
+    } catch (cleanupError) {
+      strapi2.log.debug("[Magic Editor X] Session cleanup skipped:", cleanupError.message);
+    }
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const expiredPerms = await strapi2.documents("plugin::magic-editor-x.collab-permission").findMany({
+        filters: {
+          expiresAt: { $lt: now, $ne: null }
+        },
+        limit: 1e3
+      });
+      if (expiredPerms && expiredPerms.length > 0) {
+        for (const perm of expiredPerms) {
+          await strapi2.documents("plugin::magic-editor-x.collab-permission").delete({
+            documentId: perm.documentId
+          });
+        }
+        strapi2.log.info(`[Magic Editor X] [CLEANUP] Cleaned up ${expiredPerms.length} expired permissions`);
+      }
+    } catch (cleanupError) {
+      strapi2.log.debug("[Magic Editor X] Permission cleanup skipped:", cleanupError.message);
+    }
+    if (strapi2.$io) {
+      strapi2.log.info("[Magic Editor X] [INFO] strapi-plugin-io detected - running in compatibility mode");
+    }
+    await strapi2.plugin("magic-editor-x").service("realtimeService").initSocketServer();
+    strapi2.log.info("[Magic Editor X] [SUCCESS] Realtime server started");
+  } catch (error) {
+    strapi2.log.error("[Magic Editor X] [ERROR] Bootstrap failed:", error);
+  }
+  strapi2.log.info("[Magic Editor X] Plugin bootstrapped");
+};
+var destroy$1 = async ({ strapi: strapi2 }) => {
+  try {
+    await strapi2.plugin("magic-editor-x").service("realtimeService").close();
+  } catch (error) {
+    strapi2.log.error("[Magic Editor X] Failed to gracefully shutdown realtime server", error);
+  }
+  strapi2.log.info("[Magic Editor X] Plugin destroyed");
+};
+var register$1 = ({ strapi: strapi2 }) => {
+  strapi2.customFields.register({
+    name: "richtext",
+    plugin: "magic-editor-x",
+    type: "text",
+    // Stores JSON content as text
+    inputSize: {
+      default: 12,
+      // Full width
+      isResizable: true
+    }
+  });
+  strapi2.log.info("[Magic Editor X] Custom field registered");
+};
+var config$1 = {
+  default: {
+    // Default configuration options
+    enabledTools: [
+      "header",
+      "paragraph",
+      "list",
+      "checklist",
+      "quote",
+      "warning",
+      "code",
+      "delimiter",
+      "table",
+      "embed",
+      "raw",
+      "image",
+      "mediaLib",
+      "linkTool",
+      "marker",
+      "inlineCode",
+      "underline"
+    ],
+    // Link preview timeout (ms)
+    linkPreviewTimeout: 1e4,
+    // Max image upload size (bytes)
+    maxImageSize: 10 * 1024 * 1024,
+    // 10MB
+    // Allowed image types
+    allowedImageTypes: ["image/jpeg", "image/png", "image/gif", "image/webp", "image/svg+xml"],
+    // Realtime collaboration defaults
+    collaboration: {
+      enabled: true,
+      sessionTTL: 2 * 60 * 1e3,
+      // 2 minutes
+      wsPath: "/magic-editor-x/realtime",
+      wsUrl: null,
+      allowedOrigins: [],
+      allowedAdminRoles: ["strapi-super-admin"],
+      allowedAdminUserIds: []
+    }
+  },
+  validator: (config2) => {
+    if (config2.linkPreviewTimeout && typeof config2.linkPreviewTimeout !== "number") {
+      throw new Error("[Magic Editor X] linkPreviewTimeout must be a number");
+    }
+    if (config2.maxImageSize && typeof config2.maxImageSize !== "number") {
+      throw new Error("[Magic Editor X] maxImageSize must be a number");
+    }
+    if (config2.collaboration) {
+      if (typeof config2.collaboration.enabled !== "boolean") {
+        throw new Error("[Magic Editor X] collaboration.enabled must be a boolean");
+      }
+      if (config2.collaboration.sessionTTL && typeof config2.collaboration.sessionTTL !== "number") {
+        throw new Error("[Magic Editor X] collaboration.sessionTTL must be a number");
+      }
+      ["allowedOrigins", "allowedAdminRoles", "allowedAdminUserIds"].forEach((key) => {
+        if (config2.collaboration[key] && !Array.isArray(config2.collaboration[key])) {
+          throw new Error(`[Magic Editor X] collaboration.${key} must be an array`);
+        }
+      });
+    }
+  }
+};
+var contentTypes$1 = {
+  /**
+   * Collaboration Sessions
+   * Tracks active realtime editing sessions
+   * 
+   * NOTE: Sessions are transient and should NOT be transferred.
+   * They are cleared on server restart anyway.
+   */
+  "collab-session": {
+    schema: {
+      kind: "collectionType",
+      collectionName: "magic_editor_collab_sessions",
+      info: {
+        singularName: "collab-session",
+        pluralName: "collab-sessions",
+        displayName: "Collaboration Session",
+        description: "Active realtime collaboration sessions"
+      },
+      options: {
+        draftAndPublish: false
+      },
+      pluginOptions: {
+        "content-manager": {
+          visible: false
+        },
+        "content-type-builder": {
+          visible: false
+        },
+        // Exclude from Strapi Transfer - sessions are transient
+        "import-export-entries": {
+          idField: "roomId"
+        }
+      },
+      attributes: {
+        roomId: {
+          type: "string",
+          required: true,
+          unique: true
+        },
+        contentType: {
+          type: "string",
+          required: true
+        },
+        entryId: {
+          type: "string",
+          required: true
+        },
+        fieldName: {
+          type: "string",
+          required: true
+        },
+        activeUsers: {
+          type: "json",
+          default: []
+        },
+        lastActivity: {
+          type: "datetime"
+        },
+        yjsState: {
+          type: "text",
+          default: null
+        }
+      }
+    }
+  },
+  /**
+   * Document Snapshots
+   * Periodic snapshots for version history and recovery
+   * 
+   * NOTE: Snapshots contain Yjs binary data and admin::user references.
+   * Transfer is possible but user relations may break.
+   */
+  "document-snapshot": {
+    schema: {
+      kind: "collectionType",
+      collectionName: "magic_editor_doc_snapshots",
+      info: {
+        singularName: "document-snapshot",
+        pluralName: "document-snapshots",
+        displayName: "Document Snapshot",
+        description: "Document version snapshots"
+      },
+      options: {
+        draftAndPublish: false
+      },
+      pluginOptions: {
+        "content-manager": {
+          visible: false
+        },
+        "content-type-builder": {
+          visible: false
+        },
+        // Transfer config - use roomId+version as unique identifier
+        "import-export-entries": {
+          idField: "roomId"
+        }
+      },
+      attributes: {
+        roomId: {
+          type: "string",
+          required: true
+        },
+        contentType: {
+          type: "string",
+          required: true
+        },
+        entryId: {
+          type: "string",
+          required: true
+        },
+        fieldName: {
+          type: "string",
+          required: true
+        },
+        version: {
+          type: "integer",
+          required: true
+        },
+        yjsSnapshot: {
+          type: "text",
+          required: true
+        },
+        jsonContent: {
+          type: "json"
+        },
+        createdBy: {
+          type: "relation",
+          relation: "oneToOne",
+          target: "admin::user"
+        },
+        createdAt: {
+          type: "datetime"
+        }
+      }
+    }
+  },
+  /**
+   * Collaboration Permissions
+   * Access control for realtime editing
+   * 
+   * NOTE: Permissions reference admin::user which are environment-specific.
+   * On transfer, user relations will need to be re-created manually.
+   * The contentType field can be used to match permissions.
+   */
+  "collab-permission": {
+    schema: {
+      kind: "collectionType",
+      collectionName: "magic_editor_collab_permissions",
+      info: {
+        singularName: "collab-permission",
+        pluralName: "collab-permissions",
+        displayName: "Collaboration Permission",
+        description: "User permissions for realtime editing"
+      },
+      options: {
+        draftAndPublish: false
+      },
+      pluginOptions: {
+        "content-manager": {
+          visible: false
+          // Hidden - use plugin settings page instead
+        },
+        "content-type-builder": {
+          visible: false
+        },
+        // Transfer note: admin::user relations won't transfer
+        // Permissions should be re-created in target environment
+        "import-export-entries": {
+          idField: "id"
+        }
+      },
+      attributes: {
+        contentType: {
+          type: "string",
+          required: false,
+          // null = all content types
+          default: "*"
+        },
+        entryId: {
+          type: "string"
+        },
+        fieldName: {
+          type: "string"
+        },
+        user: {
+          type: "relation",
+          relation: "oneToOne",
+          target: "admin::user",
+          required: true
+        },
+        role: {
+          type: "enumeration",
+          enum: ["viewer", "editor", "owner"],
+          default: "editor"
+        },
+        expiresAt: {
+          type: "datetime"
+        },
+        grantedBy: {
+          type: "relation",
+          relation: "oneToOne",
+          target: "admin::user"
+        }
+      }
+    }
+  }
+};
+var editorController = ({ strapi: strapi2 }) => ({
+  /**
+   * Fetch link metadata (OpenGraph) for URL preview
+   * GET /api/magic-editor-x/link?url=https://example.com
+   */
+  async fetchLinkMeta(ctx) {
+    try {
+      const { url } = ctx.query;
+      if (!url) {
+        return ctx.send({
+          success: 0,
+          message: "URL parameter is required"
+        }, 400);
+      }
+      const result = await strapi2.plugin("magic-editor-x").service("editorService").fetchLinkMeta(url);
+      ctx.send(result);
+    } catch (error) {
+      strapi2.log.error("[Magic Editor X] Link fetch error:", error);
+      ctx.send({
+        success: 0,
+        message: error.message || "Failed to fetch link metadata"
+      }, 500);
+    }
+  },
+  /**
+   * Upload image by file
+   * POST /api/magic-editor-x/image/byFile
+   * Multipart form data with files.image
+   */
+  async uploadByFile(ctx) {
+    try {
+      const result = await strapi2.plugin("magic-editor-x").service("editorService").uploadByFile(ctx);
+      ctx.send(result);
+    } catch (error) {
+      strapi2.log.error("[Magic Editor X] File upload error:", error);
+      ctx.send({
+        success: 0,
+        message: error.message || "Failed to upload file"
+      }, 500);
+    }
+  },
+  /**
+   * Upload image by URL
+   * POST /api/magic-editor-x/image/byUrl
+   * JSON body with url field
+   */
+  async uploadByUrl(ctx) {
+    try {
+      const { url } = ctx.request.body;
+      if (!url) {
+        return ctx.send({
+          success: 0,
+          message: "URL is required"
+        }, 400);
+      }
+      const result = await strapi2.plugin("magic-editor-x").service("editorService").uploadByUrl(url);
+      ctx.send(result);
+    } catch (error) {
+      strapi2.log.error("[Magic Editor X] URL upload error:", error);
+      ctx.send({
+        success: 0,
+        message: error.message || "Failed to upload from URL"
+      }, 500);
+    }
+  },
+  /**
+   * Upload file (for Attaches Tool)
+   * POST /api/magic-editor-x/file/upload
+   * Multipart form data with file
+   */
+  async uploadFile(ctx) {
+    try {
+      const result = await strapi2.plugin("magic-editor-x").service("editorService").uploadAttachment(ctx);
+      ctx.send(result);
+    } catch (error) {
+      strapi2.log.error("[Magic Editor X] Attachment upload error:", error);
+      ctx.send({
+        success: 0,
+        message: error.message || "Failed to upload attachment"
+      }, 500);
+    }
+  }
+});
+const pluginId$2 = "magic-editor-x";
+const sanitizeInitialValue = (value) => {
+  if (!value) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch (error) {
+    return "";
+  }
+};
+const verifyAdminToken = async (strapi2, ctx) => {
+  const authHeader = ctx.request.header.authorization;
+  if (!authHeader || !authHeader.startsWith("Bearer ")) {
+    return null;
+  }
+  const token = authHeader.substring(7);
+  try {
+    const decoded = await strapi2.admin.services.token.decodeJwtToken(token);
+    if (!decoded || !decoded.id) {
+      return null;
+    }
+    const adminUser = await strapi2.query("admin::user").findOne({
+      where: { id: decoded.id },
+      select: ["id", "firstname", "lastname", "email", "isActive"]
+    });
+    if (!adminUser || !adminUser.isActive) {
+      return null;
+    }
+    return adminUser;
+  } catch (error) {
+    strapi2.log.warn("[Realtime] Admin token verification failed:", error.message);
+    return null;
+  }
+};
+var realtimeController = ({ strapi: strapi2 }) => ({
+  /**
+   * POST /magic-editor-x/realtime/session
+   * Issues a short-lived collaboration token for the socket handshake.
+   */
+  async createSession(ctx) {
+    const { roomId, fieldName, meta = {}, initialValue } = ctx.request.body || {};
+    strapi2.log.info("[Realtime] createSession called with:", { roomId, fieldName });
+    if (!roomId || !fieldName) {
+      strapi2.log.warn("[Realtime] Missing roomId or fieldName");
+      return ctx.badRequest("roomId and fieldName are required");
+    }
+    let adminUser = ctx.state?.user;
+    if (!adminUser || !adminUser.email) {
+      adminUser = await verifyAdminToken(strapi2, ctx);
+    }
+    if (!adminUser) {
+      strapi2.log.warn("[Realtime] No admin user in context or invalid token");
+      return ctx.unauthorized("Admin authentication required");
+    }
+    strapi2.log.info("[Realtime] Admin user:", {
+      id: adminUser.id,
+      email: adminUser.email,
+      firstname: adminUser.firstname,
+      lastname: adminUser.lastname
+    });
+    const accessService2 = strapi2.plugin(pluginId$2).service("accessService");
+    let extractedContentType = null;
+    let extractedDocumentId = null;
+    if (roomId) {
+      const parts = roomId.split("|");
+      if (parts.length >= 1) {
+        const contentType = parts[0];
+        if (contentType && contentType.includes("::")) {
+          extractedContentType = contentType;
+        }
+        if (parts[1]) {
+          extractedDocumentId = parts[1];
+        }
+      }
+      strapi2.log.info("[Realtime] Parsed roomId:", {
+        contentType: extractedContentType,
+        documentId: extractedDocumentId,
+        roomId
+      });
+    }
+    const access = await accessService2.canUseCollaboration(adminUser, extractedContentType);
+    strapi2.log.info("[Realtime] Access check result:", {
+      allowed: access.allowed,
+      reason: access.reason || "none",
+      role: access.role || "none",
+      userId: adminUser.id,
+      userEmail: adminUser.email,
+      contentType: extractedContentType
+    });
+    if (!access.allowed) {
+      if (access.reason === "permission-required") {
+        return ctx.forbidden(
+          "Du benötigst eine Freigabe für die Echtzeit-Bearbeitung. Bitte kontaktiere einen Super Admin, um Zugriff zu erhalten."
+        );
+      }
+      return ctx.forbidden(access.reason || "Realtime collaboration is not enabled for your role");
+    }
+    const realtimeService2 = strapi2.plugin(pluginId$2).service("realtimeService");
+    try {
+      const session = realtimeService2.issueSession({
+        roomId,
+        fieldName,
+        meta,
+        user: adminUser,
+        initialValue: sanitizeInitialValue(initialValue)
+      });
+      strapi2.log.info("[Realtime] [SUCCESS] Session created successfully with role:", access.role);
+      ctx.body = {
+        ...session,
+        role: access.role || "viewer",
+        // Default to viewer if no role
+        canEdit: ["editor", "owner"].includes(access.role)
+      };
+    } catch (error) {
+      if (error.message === "collaboration-disabled") {
+        return ctx.forbidden("Realtime collaboration is disabled");
+      }
+      strapi2.log.error("[Magic Editor X] Failed to create realtime session", error);
+      ctx.internalServerError("Unable to create realtime session");
+    }
+  }
+});
+var collaborationController = ({ strapi: strapi2 }) => ({
+  /**
+   * List admin users for collaboration
+   */
+  async listAdminUsers(ctx) {
+    try {
+      const users = await strapi2.query("admin::user").findMany({
+        where: { isActive: true },
+        select: ["id", "firstname", "lastname", "email", "username"],
+        limit: 100
+      });
+      ctx.body = { data: users };
+    } catch (error) {
+      strapi2.log.error("[Collab] Error listing admin users:", error);
+      ctx.throw(500, error);
+    }
+  },
+  /**
+   * List all collaboration permissions
+   * Using Document Service API (strapi.documents) for Strapi v5
+   */
+  async listPermissions(ctx) {
+    try {
+      const permissions = await strapi2.documents("plugin::magic-editor-x.collab-permission").findMany({
+        populate: ["user", "grantedBy"],
+        sort: [{ createdAt: "desc" }]
+      });
+      ctx.body = { data: permissions };
+    } catch (error) {
+      ctx.throw(500, error);
+    }
+  },
+  /**
+   * Create collaboration permission
+   * Checks license limits before creating
+   */
+  async createPermission(ctx) {
+    try {
+      const { userId, role, contentType, entryId, fieldName, expiresAt } = ctx.request.body;
+      strapi2.log.info("[Collab] Creating permission with data:", { userId, role, contentType });
+      if (!userId || !role) {
+        strapi2.log.warn("[Collab] Missing userId or role");
+        return ctx.badRequest("userId and role are required");
+      }
+      const accessService2 = strapi2.plugin("magic-editor-x").service("accessService");
+      const limitCheck = await accessService2.checkCollaboratorLimit();
+      if (!limitCheck.canAdd) {
+        strapi2.log.warn("[Collab] Collaborator limit reached:", limitCheck);
+        return ctx.forbidden({
+          error: "Collaborator limit reached",
+          message: `You have reached the maximum of ${limitCheck.max} collaborators for your plan. Upgrade to add more.`,
+          current: limitCheck.current,
+          max: limitCheck.max,
+          upgradeRequired: true
+        });
+      }
+      const user = await strapi2.query("admin::user").findOne({
+        where: { id: userId }
+      });
+      if (!user) {
+        strapi2.log.warn("[Collab] User not found:", userId);
+        return ctx.badRequest("User not found");
+      }
+      strapi2.log.info("[Collab] Creating permission for user:", user.email);
+      const permission = await strapi2.documents("plugin::magic-editor-x.collab-permission").create({
+        data: {
+          user: userId,
+          role,
+          // null = all content types, store null not '*'
+          contentType: contentType === "*" || !contentType ? null : contentType,
+          entryId: entryId || null,
+          fieldName: fieldName || null,
+          expiresAt: expiresAt || null,
+          grantedBy: ctx.state.user.id
+        }
+      });
+      strapi2.log.info("[Collab] Permission created successfully:", permission.documentId);
+      ctx.body = { data: permission };
+    } catch (error) {
+      strapi2.log.error("[Collab] Error creating permission:", error);
+      ctx.throw(500, error.message || "Failed to create permission");
+    }
+  },
+  /**
+   * Update collaboration permission
+   * Using Document Service API (strapi.documents) for Strapi v5
+   * Note: Uses documentId instead of numeric id
+   */
+  async updatePermission(ctx) {
+    try {
+      const { id } = ctx.params;
+      const { role, contentType, entryId, fieldName, expiresAt } = ctx.request.body;
+      const updateData = {};
+      if (role !== void 0) {
+        updateData.role = role;
+      }
+      if (contentType !== void 0) {
+        updateData.contentType = contentType === "*" || contentType === null ? null : contentType;
+      }
+      if (entryId !== void 0) {
+        updateData.entryId = entryId;
+      }
+      if (fieldName !== void 0) {
+        updateData.fieldName = fieldName;
+      }
+      if (expiresAt !== void 0) {
+        updateData.expiresAt = expiresAt;
+      }
+      strapi2.log.info("[Collab] Updating permission:", { documentId: id, updateData });
+      const permission = await strapi2.documents("plugin::magic-editor-x.collab-permission").update({
+        documentId: id,
+        data: updateData
+      });
+      ctx.body = { data: permission };
+    } catch (error) {
+      strapi2.log.error("[Collab] Error updating permission:", error);
+      ctx.throw(500, error);
+    }
+  },
+  /**
+   * Delete collaboration permission
+   * Using Document Service API (strapi.documents) for Strapi v5
+   * Note: Uses documentId instead of numeric id
+   */
+  async deletePermission(ctx) {
+    try {
+      const { id } = ctx.params;
+      await strapi2.documents("plugin::magic-editor-x.collab-permission").delete({
+        documentId: id
+      });
+      ctx.body = { data: { documentId: id } };
+    } catch (error) {
+      ctx.throw(500, error);
+    }
+  },
+  /**
+   * Check if user can access a specific document
+   */
+  async checkAccess(ctx) {
+    try {
+      const { roomId, action } = ctx.query;
+      const userId = ctx.state.user.id;
+      if (!roomId) {
+        return ctx.badRequest("roomId is required");
+      }
+      const canAccess = await strapi2.plugin("magic-editor-x").service("accessService").canAccessRoom(userId, roomId, action || "view");
+      ctx.body = { data: { canAccess } };
+    } catch (error) {
+      ctx.throw(500, error);
+    }
+  }
+});
+var licenseController = ({ strapi: strapi2 }) => ({
+  /**
+   * Auto-create a FREE license with logged-in admin user data
+   */
+  async autoCreate(ctx) {
+    try {
+      const adminUser = ctx.state.user;
+      if (!adminUser) {
+        return ctx.unauthorized("No admin user logged in");
+      }
+      const licenseService2 = strapi2.plugin("magic-editor-x").service("licenseService");
+      const license2 = await licenseService2.createLicense({
+        email: adminUser.email,
+        firstName: adminUser.firstname || "Admin",
+        lastName: adminUser.lastname || "User"
+      });
+      if (!license2) {
+        return ctx.badRequest("Failed to create license");
+      }
+      await licenseService2.storeLicenseKey(license2.licenseKey);
+      const pingInterval = licenseService2.startPinging(license2.licenseKey, 15);
+      strapi2.licenseGuardEditorX = {
+        licenseKey: license2.licenseKey,
+        pingInterval,
+        data: license2,
+        tier: "free"
+      };
+      return ctx.send({
+        success: true,
+        message: "License automatically created and activated",
+        data: license2
+      });
+    } catch (error) {
+      strapi2.log.error("[Magic Editor X] Error auto-creating license:", error);
+      return ctx.badRequest("Error creating license");
+    }
+  },
+  /**
+   * Get current license status
+   */
+  async getStatus(ctx) {
+    try {
+      const licenseService2 = strapi2.plugin("magic-editor-x").service("licenseService");
+      const licenseKey = await licenseService2.getStoredLicenseKey();
+      if (!licenseKey) {
+        return ctx.send({
+          success: false,
+          demo: true,
+          valid: false,
+          tier: "free",
+          message: "No license found. Running in FREE mode."
+        });
+      }
+      const verification = await licenseService2.verifyLicense(licenseKey);
+      const license2 = await licenseService2.getLicenseByKey(licenseKey);
+      const tier = await licenseService2.getCurrentTier();
+      return ctx.send({
+        success: true,
+        valid: verification.valid,
+        demo: false,
+        tier,
+        data: {
+          licenseKey,
+          email: license2?.email || null,
+          firstName: license2?.firstName || null,
+          lastName: license2?.lastName || null,
+          isActive: license2?.isActive || false,
+          isExpired: license2?.isExpired || false,
+          isOnline: license2?.isOnline || false,
+          expiresAt: license2?.expiresAt,
+          lastPingAt: license2?.lastPingAt,
+          deviceName: license2?.deviceName,
+          features: {
+            premium: license2?.featurePremium || false,
+            advanced: license2?.featureAdvanced || false,
+            enterprise: license2?.featureEnterprise || false
+          }
+        }
+      });
+    } catch (error) {
+      strapi2.log.error("[Magic Editor X] Error getting license status:", error);
+      return ctx.badRequest("Error getting license status");
+    }
+  },
+  /**
+   * Store and validate an existing license key
+   */
+  async storeKey(ctx) {
+    try {
+      const { licenseKey, email } = ctx.request.body;
+      if (!licenseKey || !licenseKey.trim()) {
+        return ctx.badRequest("License key is required");
+      }
+      if (!email || !email.trim()) {
+        return ctx.badRequest("Email address is required");
+      }
+      const trimmedKey = licenseKey.trim();
+      const trimmedEmail = email.trim().toLowerCase();
+      const licenseService2 = strapi2.plugin("magic-editor-x").service("licenseService");
+      const verification = await licenseService2.verifyLicense(trimmedKey);
+      if (!verification.valid) {
+        strapi2.log.warn(`[Magic Editor X] [WARNING] Invalid license key attempted: ${trimmedKey.substring(0, 8)}...`);
+        return ctx.badRequest("Invalid or expired license key");
+      }
+      const license2 = await licenseService2.getLicenseByKey(trimmedKey);
+      if (!license2) {
+        return ctx.badRequest("License not found");
+      }
+      if (license2.email.toLowerCase() !== trimmedEmail) {
+        strapi2.log.warn(`[Magic Editor X] [WARNING] Email mismatch for license key`);
+        return ctx.badRequest("Email address does not match this license key");
+      }
+      await licenseService2.storeLicenseKey(trimmedKey);
+      const pingInterval = licenseService2.startPinging(trimmedKey, 15);
+      const tier = await licenseService2.getCurrentTier();
+      strapi2.licenseGuardEditorX = {
+        licenseKey: trimmedKey,
+        pingInterval,
+        data: verification.data,
+        tier
+      };
+      strapi2.log.info(`[Magic Editor X] [SUCCESS] License validated and stored`);
+      return ctx.send({
+        success: true,
+        message: "License activated successfully",
+        tier,
+        data: verification.data
+      });
+    } catch (error) {
+      strapi2.log.error("[Magic Editor X] Error storing license key:", error);
+      return ctx.badRequest("Error storing license key");
+    }
+  },
+  /**
+   * Get license limits and available features
+   */
+  async getLimits(ctx) {
+    try {
+      const licenseService2 = strapi2.plugin("magic-editor-x").service("licenseService");
+      const tier = await licenseService2.getCurrentTier();
+      const tierConfig = licenseService2.getTierConfig(tier);
+      const collaboratorCheck = await licenseService2.canAddCollaborator();
+      ctx.body = {
+        success: true,
+        tier,
+        tierName: tierConfig.name,
+        limits: {
+          collaborators: {
+            current: collaboratorCheck.current,
+            max: collaboratorCheck.max,
+            unlimited: collaboratorCheck.unlimited,
+            canAdd: collaboratorCheck.canAdd
+          }
+        },
+        features: tierConfig.features
+      };
+    } catch (error) {
+      strapi2.log.error("[Magic Editor X] Error getting license limits:", error);
+      ctx.throw(500, "Error getting license limits");
+    }
+  },
+  /**
+   * Check if user can add a collaborator (used by frontend)
+   */
+  async canAddCollaborator(ctx) {
+    try {
+      const licenseService2 = strapi2.plugin("magic-editor-x").service("licenseService");
+      const result = await licenseService2.canAddCollaborator();
+      ctx.body = {
+        success: true,
+        ...result
+      };
+    } catch (error) {
+      strapi2.log.error("[Magic Editor X] Error checking collaborator limit:", error);
+      ctx.throw(500, "Error checking collaborator limit");
+    }
+  }
+});
+const editor = editorController;
+const realtime = realtimeController;
+const collaboration = collaborationController;
+const license$1 = licenseController;
+var controllers$1 = {
+  editor,
+  realtime,
+  collaboration,
+  license: license$1
+};
+var middlewares$1 = {};
+var policies$1 = {};
+var admin$1 = {
+  type: "admin",
+  routes: [
+    // Collaboration Session
+    {
+      method: "POST",
+      path: "/collab/session",
+      handler: "realtime.createSession",
+      config: {
+        policies: []
+      }
+    },
+    // Collaboration Users & Permissions
+    {
+      method: "GET",
+      path: "/collaboration/users",
+      handler: "collaboration.listAdminUsers",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "GET",
+      path: "/collaboration/permissions",
+      handler: "collaboration.listPermissions",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "POST",
+      path: "/collaboration/permissions",
+      handler: "collaboration.createPermission",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "PUT",
+      path: "/collaboration/permissions/:id",
+      handler: "collaboration.updatePermission",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "DELETE",
+      path: "/collaboration/permissions/:id",
+      handler: "collaboration.deletePermission",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "GET",
+      path: "/collaboration/check-access",
+      handler: "collaboration.checkAccess",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    // License Management
+    {
+      method: "GET",
+      path: "/license/status",
+      handler: "license.getStatus",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "POST",
+      path: "/license/auto-create",
+      handler: "license.autoCreate",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "POST",
+      path: "/license/store-key",
+      handler: "license.storeKey",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "GET",
+      path: "/license/limits",
+      handler: "license.getLimits",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "GET",
+      path: "/license/can-add-collaborator",
+      handler: "license.canAddCollaborator",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    }
+  ]
+};
+var contentApi$1 = {
+  type: "content-api",
+  routes: [
+    /**
+     * Link Preview Endpoint
+     * GET /api/magic-editor-x/link?url=https://example.com
+     * Returns OpenGraph metadata for URL
+     */
+    {
+      method: "GET",
+      path: "/link",
+      handler: "editor.fetchLinkMeta",
+      config: {
+        description: "Fetch link metadata (OpenGraph) for URL preview",
+        auth: false,
+        policies: []
+      }
+    },
+    /**
+     * Upload Image by File
+     * POST /api/magic-editor-x/image/byFile
+     * Multipart form data with files.image
+     */
+    {
+      method: "POST",
+      path: "/image/byFile",
+      handler: "editor.uploadByFile",
+      config: {
+        description: "Upload image by file to Strapi Media Library",
+        auth: false,
+        policies: []
+      }
+    },
+    /**
+     * Upload Image by URL
+     * POST /api/magic-editor-x/image/byUrl
+     * JSON body with url field
+     */
+    {
+      method: "POST",
+      path: "/image/byUrl",
+      handler: "editor.uploadByUrl",
+      config: {
+        description: "Upload image by URL to Strapi Media Library",
+        auth: false,
+        policies: []
+      }
+    },
+    /**
+     * Upload File (for Attaches Tool)
+     * POST /api/magic-editor-x/file/upload
+     * Multipart form data with file
+     */
+    {
+      method: "POST",
+      path: "/file/upload",
+      handler: "editor.uploadFile",
+      config: {
+        description: "Upload file to Strapi Media Library (for Attaches)",
+        auth: false,
+        policies: []
+      }
+    }
+  ]
+};
+const admin = admin$1;
+const contentApi = contentApi$1;
+var routes$1 = {
+  admin,
+  "content-api": contentApi
+};
+const ogs = require$$0;
+const fs = require$$1;
+const path = require$$2$1;
+const https = require$$3;
+const http = require$$4;
+const { URL } = require$$5;
+var editorService$1 = ({ strapi: strapi2 }) => ({
+  /**
+   * Fetch OpenGraph metadata for a URL
+   * @param {string} url - URL to fetch metadata from
+   * @returns {object} EditorJS compatible link data
+   */
+  async fetchLinkMeta(url) {
+    try {
+      const options = {
+        url,
+        timeout: 1e4,
+        fetchOptions: {
+          headers: {
+            "User-Agent": "Mozilla/5.0 (compatible; MagicEditorX/1.0)"
+          }
+        }
+      };
+      const { result, error } = await ogs(options);
+      if (error) {
+        strapi2.log.warn("[Magic Editor X] OGS error:", error);
+        return {
+          success: 1,
+          meta: {
+            title: url,
+            description: "",
+            image: void 0
+          }
+        };
+      }
+      let imageUrl = void 0;
+      if (result.ogImage) {
+        if (Array.isArray(result.ogImage) && result.ogImage.length > 0) {
+          imageUrl = { url: result.ogImage[0].url };
+        } else if (result.ogImage.url) {
+          imageUrl = { url: result.ogImage.url };
+        }
+      }
+      return {
+        success: 1,
+        meta: {
+          title: result.ogTitle || result.dcTitle || url,
+          description: result.ogDescription || result.dcDescription || "",
+          image: imageUrl,
+          siteName: result.ogSiteName || "",
+          url: result.ogUrl || url
+        }
+      };
+    } catch (error) {
+      strapi2.log.error("[Magic Editor X] Link meta fetch error:", error);
+      return {
+        success: 1,
+        meta: {
+          title: url,
+          description: "",
+          image: void 0
+        }
+      };
+    }
+  },
+  /**
+   * Upload image from multipart form data
+   * @param {object} ctx - Koa context
+   * @returns {object} EditorJS compatible upload result
+   */
+  async uploadByFile(ctx) {
+    try {
+      const { files: files2 } = ctx.request;
+      if (!files2 || !files2["files.image"]) {
+        throw new Error("No file provided");
+      }
+      const file = files2["files.image"];
+      const uploadService = strapi2.plugin("upload").service("upload");
+      const uploadedFiles = await uploadService.upload({
+        data: {},
+        files: Array.isArray(file) ? file : [file]
+      });
+      const uploadedFile = uploadedFiles[0];
+      return {
+        success: 1,
+        file: {
+          url: uploadedFile.url,
+          name: uploadedFile.name,
+          size: uploadedFile.size,
+          width: uploadedFile.width,
+          height: uploadedFile.height,
+          mime: uploadedFile.mime,
+          formats: uploadedFile.formats
+        }
+      };
+    } catch (error) {
+      strapi2.log.error("[Magic Editor X] File upload error:", error);
+      throw error;
+    }
+  },
+  /**
+   * Download and upload image from URL
+   * @param {string} imageUrl - URL of image to download
+   * @returns {object} EditorJS compatible upload result
+   */
+  async uploadByUrl(imageUrl) {
+    try {
+      const parsedUrl = new URL(imageUrl);
+      const pathname = parsedUrl.pathname;
+      const ext = path.extname(pathname) || ".jpg";
+      const name2 = path.basename(pathname, ext) || "image";
+      const filename = `${name2}${ext}`;
+      const tempDir = path.join(strapi2.dirs.static.public, "uploads", "temp");
+      if (!fs.existsSync(tempDir)) {
+        fs.mkdirSync(tempDir, { recursive: true });
+      }
+      const tempFilePath = path.join(tempDir, `${Date.now()}-${filename}`);
+      const buffer = await this.downloadFile(imageUrl);
+      await fs.promises.writeFile(tempFilePath, buffer);
+      const stats = await fs.promises.stat(tempFilePath);
+      const fileData = {
+        path: tempFilePath,
+        name: filename,
+        type: this.getMimeType(ext),
+        size: stats.size
+      };
+      const uploadService = strapi2.plugin("upload").service("upload");
+      const uploadedFiles = await uploadService.upload({
+        data: {},
+        files: fileData
+      });
+      try {
+        await fs.promises.unlink(tempFilePath);
+      } catch (unlinkError) {
+        strapi2.log.warn("[Magic Editor X] Could not delete temp file:", unlinkError);
+      }
+      const uploadedFile = uploadedFiles[0];
+      return {
+        success: 1,
+        file: {
+          url: uploadedFile.url,
+          name: uploadedFile.name,
+          size: uploadedFile.size,
+          width: uploadedFile.width,
+          height: uploadedFile.height,
+          mime: uploadedFile.mime,
+          formats: uploadedFile.formats
+        }
+      };
+    } catch (error) {
+      strapi2.log.error("[Magic Editor X] URL upload error:", error);
+      throw error;
+    }
+  },
+  /**
+   * Download file from URL
+   * @param {string} url - URL to download from
+   * @returns {Promise<Buffer>} File buffer
+   */
+  downloadFile(url) {
+    return new Promise((resolve, reject) => {
+      const protocol = url.startsWith("https") ? https : http;
+      const request = protocol.get(url, {
+        headers: {
+          "User-Agent": "Mozilla/5.0 (compatible; MagicEditorX/1.0)"
+        }
+      }, (response) => {
+        if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+          return this.downloadFile(response.headers.location).then(resolve).catch(reject);
+        }
+        if (response.statusCode !== 200) {
+          reject(new Error(`Failed to download: ${response.statusCode}`));
+          return;
+        }
+        const chunks = [];
+        response.on("data", (chunk) => chunks.push(chunk));
+        response.on("end", () => resolve(Buffer.concat(chunks)));
+        response.on("error", reject);
+      });
+      request.on("error", reject);
+      request.setTimeout(3e4, () => {
+        request.destroy();
+        reject(new Error("Download timeout"));
+      });
+    });
+  },
+  /**
+   * Get MIME type from file extension
+   * @param {string} ext - File extension
+   * @returns {string} MIME type
+   */
+  getMimeType(ext) {
+    const mimeTypes = {
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".png": "image/png",
+      ".gif": "image/gif",
+      ".webp": "image/webp",
+      ".svg": "image/svg+xml",
+      ".ico": "image/x-icon",
+      ".bmp": "image/bmp",
+      ".tiff": "image/tiff",
+      ".tif": "image/tiff",
+      // Documents
+      ".pdf": "application/pdf",
+      ".doc": "application/msword",
+      ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      ".xls": "application/vnd.ms-excel",
+      ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      ".ppt": "application/vnd.ms-powerpoint",
+      ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+      // Archives
+      ".zip": "application/zip",
+      ".rar": "application/vnd.rar",
+      ".7z": "application/x-7z-compressed",
+      ".tar": "application/x-tar",
+      ".gz": "application/gzip",
+      // Text
+      ".txt": "text/plain",
+      ".csv": "text/csv",
+      ".json": "application/json",
+      ".xml": "application/xml",
+      // Audio
+      ".mp3": "audio/mpeg",
+      ".wav": "audio/wav",
+      ".ogg": "audio/ogg",
+      // Video
+      ".mp4": "video/mp4",
+      ".webm": "video/webm",
+      ".avi": "video/x-msvideo"
+    };
+    return mimeTypes[ext.toLowerCase()] || "application/octet-stream";
+  },
+  /**
+   * Upload attachment file (for Attaches Tool)
+   * @param {object} ctx - Koa context
+   * @returns {object} EditorJS compatible attachment result
+   */
+  async uploadAttachment(ctx) {
+    try {
+      const { files: files2 } = ctx.request;
+      const file = files2?.file || files2?.["files.file"] || Object.values(files2 || {})[0];
+      if (!file) {
+        throw new Error("No file provided");
+      }
+      const uploadService = strapi2.plugin("upload").service("upload");
+      const uploadedFiles = await uploadService.upload({
+        data: {},
+        files: Array.isArray(file) ? file : [file]
+      });
+      const uploadedFile = uploadedFiles[0];
+      const ext = path.extname(uploadedFile.name);
+      return {
+        success: 1,
+        file: {
+          url: uploadedFile.url,
+          name: uploadedFile.name,
+          title: uploadedFile.name,
+          size: uploadedFile.size,
+          extension: ext.replace(".", "")
+        }
+      };
+    } catch (error) {
+      strapi2.log.error("[Magic Editor X] Attachment upload error:", error);
+      throw error;
+    }
+  }
+});
+const { randomUUID } = require$$0$1;
+const { Server } = require$$1$1;
+const Y = require$$2$2;
+const pluginId$1 = "magic-editor-x";
+const DEFAULT_SOCKET_PATH = "/magic-editor-x/realtime";
+const DEFAULT_CORS_CONFIG = {
+  origin: "*",
+  methods: ["GET", "POST"],
+  credentials: true
+};
+const isPluginIoActive = (strapi2) => {
+  try {
+    return !!strapi2.$io;
+  } catch {
+    return false;
+  }
+};
+var realtimeService$1 = ({ strapi: strapi2 }) => {
+  const rooms = /* @__PURE__ */ new Map();
+  const sessionTokens = /* @__PURE__ */ new Map();
+  let io;
+  let cleanupInterval;
+  const getConfig = () => strapi2.config.get(`plugin::${pluginId$1}`, {});
+  const cleanupStaleRooms = () => {
+    if (!io) return;
+    const now = Date.now();
+    const STALE_THRESHOLD = 60 * 60 * 1e3;
+    let removedCount = 0;
+    rooms.forEach((room, roomId) => {
+      const socketsInRoom = io.sockets.adapter.rooms.get(roomId);
+      const connectionCount = socketsInRoom ? socketsInRoom.size : 0;
+      if (connectionCount === 0) {
+        if (now - room.updatedAt > STALE_THRESHOLD) {
+          room.doc.destroy();
+          rooms.delete(roomId);
+          removedCount++;
+        }
+      }
+    });
+    if (removedCount > 0) {
+      strapi2.log.info(`[Magic Editor X] [CLEANUP] Removed ${removedCount} stale rooms`);
+    }
+  };
+  if (!cleanupInterval) {
+    cleanupInterval = setInterval(cleanupStaleRooms, 15 * 60 * 1e3);
+  }
+  const ensureRoom = (roomId) => {
+    if (!rooms.has(roomId)) {
+      const doc = new Y.Doc();
+      rooms.set(roomId, {
+        roomId,
+        doc,
+        initialized: false,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        meta: {}
+      });
+      doc.on("update", () => {
+        const room = rooms.get(roomId);
+        if (room) {
+          room.initialized = true;
+          room.updatedAt = Date.now();
+        }
+      });
+    }
+    return rooms.get(roomId);
+  };
+  const initializeDoc = (roomId, initialValue) => {
+    const room = ensureRoom(roomId);
+    const blocksMap = room.doc.getMap("blocks");
+    const isDocEmpty = blocksMap.size === 0;
+    if (!initialValue || !isDocEmpty && room.initialized) {
+      return room;
+    }
+    try {
+      const data = JSON.parse(initialValue);
+      const blocks = data?.blocks || [];
+      const time = data?.time || Date.now();
+      room.doc.transact(() => {
+        const metaMap = room.doc.getMap("meta");
+        for (const block of blocks) {
+          if (block.id) {
+            blocksMap.set(block.id, JSON.stringify(block));
+          }
+        }
+        metaMap.set("time", time);
+        metaMap.set("blockOrder", JSON.stringify(blocks.map((b) => b.id)));
+      }, "bootstrap");
+      room.initialized = true;
+      strapi2.log.info(`[Magic Editor X] [INIT] Initialized room ${roomId} with ${blocks.length} blocks`);
+    } catch (error) {
+      strapi2.log.error(`[Magic Editor X] Failed to initialize Y.Doc for room ${roomId}`, error);
+    }
+    return room;
+  };
+  const getStateUpdate = (roomId) => {
+    const room = ensureRoom(roomId);
+    try {
+      return Y.encodeStateAsUpdate(room.doc);
+    } catch (error) {
+      strapi2.log.error(`[Magic Editor X] Failed to encode state for room ${roomId}`, error);
+      return null;
+    }
+  };
+  const applyUpdate2 = (roomId, update, origin = "remote") => {
+    if (!update) {
+      return;
+    }
+    const room = ensureRoom(roomId);
+    try {
+      Y.applyUpdate(room.doc, update, origin);
+    } catch (error) {
+      strapi2.log.error(`[Magic Editor X] Failed to apply update for room ${roomId}`, error);
+    }
+  };
+  const issueSession = ({ roomId, fieldName, meta = {}, user, initialValue = "" }) => {
+    const pluginConfig = getConfig();
+    const collabConfig = pluginConfig.collaboration || {};
+    if (collabConfig.enabled === false) {
+      throw new Error("collaboration-disabled");
+    }
+    initializeDoc(roomId, initialValue);
+    const token = randomUUID();
+    const expiresAt = Date.now() + (collabConfig.sessionTTL || 2 * 60 * 1e3);
+    sessionTokens.set(token, {
+      token,
+      roomId,
+      fieldName,
+      meta,
+      user: {
+        id: user.id,
+        firstname: user.firstname,
+        lastname: user.lastname,
+        email: user.email,
+        roles: user.roles?.map((role) => ({
+          id: role.id,
+          code: role.code,
+          name: role.name
+        })) || []
+      },
+      expiresAt
+    });
+    const actualPath = io?._magicEditorPath || collabConfig.wsPath || DEFAULT_SOCKET_PATH;
+    return {
+      token,
+      roomId,
+      expiresAt,
+      wsPath: actualPath,
+      wsUrl: collabConfig.wsUrl || void 0,
+      approvals: {
+        roleApproved: true
+      }
+    };
+  };
+  const consumeSessionToken = (token) => {
+    if (!token) {
+      return null;
+    }
+    const session = sessionTokens.get(token);
+    if (!session) {
+      return null;
+    }
+    if (session.expiresAt < Date.now()) {
+      sessionTokens.delete(token);
+      return null;
+    }
+    sessionTokens.delete(token);
+    return session;
+  };
+  const initSocketServer = () => {
+    const pluginConfig = getConfig();
+    const collabConfig = pluginConfig.collaboration || {};
+    if (collabConfig.enabled === false) {
+      strapi2.log.info("[Magic Editor X] Realtime server disabled (collaboration.enabled=false)");
+      return null;
+    }
+    if (io) {
+      return io;
+    }
+    const httpServer = strapi2.server.httpServer;
+    if (!httpServer) {
+      strapi2.log.warn("[Magic Editor X] HTTP server not ready. Realtime collaboration skipped.");
+      return null;
+    }
+    if (isPluginIoActive(strapi2)) {
+      strapi2.log.info("[Magic Editor X] [INFO] strapi-plugin-io detected - using separate namespace");
+    }
+    const wsPath = collabConfig.wsPath || DEFAULT_SOCKET_PATH;
+    if (wsPath === "/socket.io") {
+      strapi2.log.warn('[Magic Editor X] [WARNING] wsPath "/socket.io" conflicts with strapi-plugin-io!');
+      strapi2.log.warn("[Magic Editor X] Using default path instead: " + DEFAULT_SOCKET_PATH);
+    }
+    const finalPath = wsPath === "/socket.io" ? DEFAULT_SOCKET_PATH : wsPath;
+    strapi2.log.info(`[Magic Editor X] [SOCKET] Starting Socket.io server on path: ${finalPath}`);
+    io = new Server(httpServer, {
+      path: finalPath,
+      cors: collabConfig.cors || DEFAULT_CORS_CONFIG,
+      transports: ["websocket", "polling"],
+      allowEIO3: true,
+      // Backward compatibility
+      // Avoid conflicts with other Socket.io instances
+      serveClient: false,
+      // Don't serve socket.io client files
+      connectTimeout: 45e3
+    });
+    io._magicEditorPath = finalPath;
+    io.on("connection", (socket) => {
+      const token = socket.handshake.auth?.token;
+      strapi2.log.info(`[Magic Editor X] [SOCKET] Client connecting with token: ${token ? "valid" : "missing"}`);
+      const session = consumeSessionToken(token);
+      if (!session) {
+        strapi2.log.warn("[Magic Editor X] [WARNING] Invalid or expired token");
+        socket.emit("collab:error", { code: "INVALID_TOKEN", message: "Invalid or expired session token" });
+        socket.disconnect(true);
+        return;
+      }
+      const { roomId, user } = session;
+      socket.data.user = user;
+      socket.data.roomId = roomId;
+      socket.join(roomId);
+      strapi2.log.info(`[Magic Editor X] [SUCCESS] User ${user.email} joined room: ${roomId}`);
+      const initialState = getStateUpdate(roomId);
+      if (initialState) {
+        const stateArray = Array.from(initialState);
+        socket.emit("collab:sync", stateArray);
+        strapi2.log.info(`[Magic Editor X] [SYNC] Sent initial state (${stateArray.length} bytes)`);
+      }
+      const socketsInRoom = io.sockets.adapter.rooms.get(roomId);
+      if (socketsInRoom) {
+        const existingPeers = [];
+        for (const socketId of socketsInRoom) {
+          const peerSocket = io.sockets.sockets.get(socketId);
+          if (peerSocket && peerSocket.data.user && peerSocket.id !== socket.id) {
+            existingPeers.push(peerSocket.data.user);
+          }
+        }
+        existingPeers.forEach((peerUser) => {
+          socket.emit("collab:presence", { type: "join", user: peerUser });
+        });
+        strapi2.log.info(`[Magic Editor X] [PEERS] Sent ${existingPeers.length} existing peers to new user`);
+      }
+      socket.to(roomId).emit("collab:presence", { type: "join", user });
+      socket.on("collab:update", (update) => {
+        try {
+          const updateBuffer = new Uint8Array(update);
+          applyUpdate2(roomId, updateBuffer, "remote");
+          socket.to(roomId).emit("collab:update", update);
+          strapi2.log.debug(`[Magic Editor X] [BROADCAST] Update broadcast to room ${roomId}`);
+        } catch (error) {
+          strapi2.log.error("[Magic Editor X] Failed to process update:", error);
+          socket.emit("collab:error", { code: "UPDATE_FAILED", message: "Failed to process update" });
+        }
+      });
+      socket.on("collab:awareness", (payload) => {
+        socket.to(roomId).emit("collab:awareness", { user, payload });
+      });
+      socket.on("disconnect", (reason) => {
+        strapi2.log.info(`[Magic Editor X] [DISCONNECT] User ${user.email} left room ${roomId} (${reason})`);
+        socket.to(roomId).emit("collab:presence", { type: "leave", user });
+      });
+      socket.on("error", (error) => {
+        strapi2.log.error("[Magic Editor X] Socket error:", error);
+      });
+    });
+    strapi2.log.info("[Magic Editor X] [SUCCESS] Realtime collaboration server ready");
+    return io;
+  };
+  const close = async () => {
+    if (cleanupInterval) {
+      clearInterval(cleanupInterval);
+      cleanupInterval = null;
+    }
+    if (io) {
+      await io.close();
+      io = null;
+    }
+    sessionTokens.clear();
+    rooms.forEach((room) => room.doc.destroy());
+    rooms.clear();
+  };
+  return {
+    issueSession,
+    consumeSessionToken,
+    applyUpdate: applyUpdate2,
+    initSocketServer,
+    close
+  };
+};
+const pluginId = "magic-editor-x";
+const getRoleCodes = (user) => {
+  if (!user?.roles) {
+    return [];
+  }
+  return user.roles.map((role) => role?.code || role?.name).filter(Boolean);
+};
+var accessService$1 = ({ strapi: strapi2 }) => {
+  const getConfig = () => strapi2.config.get(`plugin::${pluginId}`, {});
+  return {
+    /**
+     * Prüft ob ein User Collaboration nutzen darf
+     * Standard: Nur Super Admins haben automatisch Zugriff
+     * Alle anderen brauchen explizite Freigabe über collab-permission
+     * 
+     * @param {Object} user - Der Admin User
+     * @param {string} contentType - Optional: Der spezifische Content Type (z.B. 'api::article.article')
+     */
+    async canUseCollaboration(user, contentType = null) {
+      if (!user) {
+        strapi2.log.warn("[Access Service] No user provided");
+        return { allowed: false, reason: "not-authenticated", role: null };
+      }
+      strapi2.log.info("[Access Service] Checking access for user:", user.email, "contentType:", contentType);
+      const config2 = getConfig();
+      const collab = config2.collaboration || {};
+      if (collab.enabled === false) {
+        strapi2.log.info("[Access Service] Collaboration is disabled");
+        return { allowed: false, reason: "collaboration-disabled", role: null };
+      }
+      const userRoleCodes = getRoleCodes(user);
+      const isSuperAdmin = userRoleCodes.includes("strapi-super-admin");
+      strapi2.log.info("[Access Service] User roles:", userRoleCodes, "isSuperAdmin:", isSuperAdmin);
+      if (isSuperAdmin) {
+        strapi2.log.info("[Access Service] [SUCCESS] Super Admin access granted");
+        return { allowed: true, reason: "super-admin", role: "owner" };
+      }
+      try {
+        const permissions = await strapi2.documents("plugin::magic-editor-x.collab-permission").findMany({
+          filters: {
+            user: { id: user.id }
+          }
+        });
+        strapi2.log.info("[Access Service] Found permissions:", permissions?.length || 0);
+        if (permissions && permissions.length > 0) {
+          let bestPermission = null;
+          for (const perm of permissions) {
+            strapi2.log.info("[Access Service] Checking permission:", {
+              permContentType: perm.contentType,
+              requestedContentType: contentType,
+              role: perm.role,
+              expiresAt: perm.expiresAt
+            });
+            if (perm.expiresAt && new Date(perm.expiresAt) < /* @__PURE__ */ new Date()) {
+              strapi2.log.info("[Access Service] Permission expired, skipping");
+              continue;
+            }
+            if (!perm.contentType || perm.contentType === "*" || perm.contentType === "") {
+              strapi2.log.info("[Access Service] ✅ Global permission found");
+              if (!bestPermission || this.getRoleLevel(perm.role) > this.getRoleLevel(bestPermission.role)) {
+                bestPermission = perm;
+              }
+            } else if (contentType && perm.contentType === contentType) {
+              strapi2.log.info("[Access Service] ✅ Specific content type match");
+              bestPermission = perm;
+              break;
+            } else if (!contentType || contentType === "unknown") {
+              strapi2.log.info("[Access Service] ✅ Unknown/null contentType - accepting any permission");
+              if (!bestPermission || this.getRoleLevel(perm.role) > this.getRoleLevel(bestPermission.role)) {
+                bestPermission = perm;
+              }
+            }
+          }
+          if (bestPermission) {
+            strapi2.log.info("[Access Service] ✅ Permission granted via collab-permission, role:", bestPermission.role);
+            return {
+              allowed: true,
+              reason: "explicit-permission",
+              role: bestPermission.role,
+              permission: bestPermission
+            };
+          }
+        }
+      } catch (error) {
+        strapi2.log.error("[Access Service] Error checking permissions:", error);
+      }
+      strapi2.log.info("[Access Service] [DENIED] No permission found for user");
+      return { allowed: false, reason: "permission-required", role: null };
+    },
+    /**
+     * Hilfsfunktion: Gibt Rollen-Level zurück (höher = mehr Rechte)
+     */
+    getRoleLevel(role) {
+      const levels = { viewer: 1, editor: 2, owner: 3 };
+      return levels[role] || 0;
+    },
+    /**
+     * Checks if a new collaborator can be added based on license limits
+     * @returns {Promise<object>} Result with canAdd, current, max, and unlimited flags
+     */
+    async checkCollaboratorLimit() {
+      try {
+        const licenseService2 = strapi2.plugin("magic-editor-x").service("licenseService");
+        return await licenseService2.canAddCollaborator();
+      } catch (error) {
+        strapi2.log.error("[Access Service] Error checking collaborator limit:", error);
+        return {
+          canAdd: true,
+          current: 0,
+          max: 2,
+          unlimited: false,
+          error: true
+        };
+      }
+    },
+    /**
+     * Prüft ob User Zugriff auf einen bestimmten Room hat
+     */
+    async canAccessRoom(userId, roomId, action = "view") {
+      try {
+        const user = await strapi2.query("admin::user").findOne({
+          where: { id: userId },
+          populate: ["roles"]
+        });
+        if (!user) {
+          return false;
+        }
+        const userRoleCodes = getRoleCodes(user);
+        const isSuperAdmin = userRoleCodes.includes("strapi-super-admin");
+        if (isSuperAdmin) {
+          return true;
+        }
+        let contentTypeFromRoom = null;
+        if (roomId) {
+          const parts = roomId.split("|");
+          if (parts.length >= 1 && parts[0]?.includes("::")) {
+            contentTypeFromRoom = parts[0];
+          }
+        }
+        const permissions = await strapi2.documents("plugin::magic-editor-x.collab-permission").findMany({
+          filters: {
+            user: { id: userId }
+          }
+        });
+        if (!permissions || permissions.length === 0) {
+          return false;
+        }
+        const hasValidPermission = permissions.some((perm) => {
+          if (!perm.contentType || perm.contentType === "*") {
+            return true;
+          }
+          if (contentTypeFromRoom && perm.contentType === contentTypeFromRoom) {
+            return true;
+          }
+          return false;
+        });
+        if (!hasValidPermission) {
+          return false;
+        }
+        const permission = permissions[0];
+        if (action === "view") {
+          return ["viewer", "editor", "owner"].includes(permission.role);
+        }
+        if (action === "edit") {
+          return ["editor", "owner"].includes(permission.role);
+        }
+        if (action === "manage") {
+          return permission.role === "owner";
+        }
+        return false;
+      } catch (error) {
+        strapi2.log.error("[Access Service] Error checking room access:", error);
+        return false;
+      }
+    }
+  };
+};
+const { encodeStateAsUpdate, encodeStateVector, applyUpdate } = require$$2$2;
+var snapshotService$1 = ({ strapi: strapi2 }) => ({
+  /**
+   * Create snapshot from Y.Doc
+   */
+  async createSnapshot(roomId, contentType, entryId, fieldName, ydoc, userId) {
+    try {
+      const latestSnapshots = await strapi2.documents("plugin::magic-editor-x.document-snapshot").findMany({
+        filters: { roomId },
+        sort: [{ version: "desc" }],
+        limit: 1
+      });
+      const nextVersion = latestSnapshots?.[0]?.version ? latestSnapshots[0].version + 1 : 1;
+      const yjsState = encodeStateAsUpdate(ydoc);
+      const yjsSnapshot = Buffer.from(yjsState).toString("base64");
+      let jsonContent = null;
+      try {
+        const text = ydoc.getText("content");
+        jsonContent = text.toString();
+      } catch (e) {
+        strapi2.log.warn("[Snapshot] Could not extract JSON content:", e);
+      }
+      const snapshot = await strapi2.documents("plugin::magic-editor-x.document-snapshot").create({
+        data: {
+          roomId,
+          contentType,
+          entryId,
+          fieldName,
+          version: nextVersion,
+          yjsSnapshot,
+          jsonContent: jsonContent ? JSON.parse(jsonContent) : null,
+          createdBy: userId,
+          createdAt: /* @__PURE__ */ new Date()
+        }
+      });
+      strapi2.log.info(`[Snapshot] Created v${nextVersion} for ${roomId}`);
+      return snapshot;
+    } catch (error) {
+      strapi2.log.error("[Snapshot] Error creating snapshot:", error);
+      throw error;
+    }
+  },
+  /**
+   * List snapshots for a room
+   */
+  async listSnapshots(roomId, limit = 50) {
+    return await strapi2.documents("plugin::magic-editor-x.document-snapshot").findMany({
+      filters: { roomId },
+      sort: [{ version: "desc" }],
+      limit,
+      populate: ["createdBy"]
+    });
+  },
+  /**
+   * Restore snapshot to Y.Doc
+   * Note: Uses documentId instead of numeric id
+   */
+  async restoreSnapshot(snapshotDocumentId, ydoc) {
+    try {
+      const snapshot = await strapi2.documents("plugin::magic-editor-x.document-snapshot").findOne({
+        documentId: snapshotDocumentId
+      });
+      if (!snapshot) {
+        throw new Error("Snapshot not found");
+      }
+      const yjsState = Buffer.from(snapshot.yjsSnapshot, "base64");
+      applyUpdate(ydoc, yjsState);
+      strapi2.log.info(`[Snapshot] Restored v${snapshot.version} for ${snapshot.roomId}`);
+      return snapshot;
+    } catch (error) {
+      strapi2.log.error("[Snapshot] Error restoring snapshot:", error);
+      throw error;
+    }
+  },
+  /**
+   * Auto-cleanup old snapshots (keep last N versions)
+   */
+  async cleanupSnapshots(roomId, keepLast = 10) {
+    try {
+      const snapshots = await this.listSnapshots(roomId, 1e3);
+      if (snapshots.length <= keepLast) {
+        return { deleted: 0 };
+      }
+      const toDelete = snapshots.slice(keepLast);
+      for (const snapshot of toDelete) {
+        await strapi2.documents("plugin::magic-editor-x.document-snapshot").delete({
+          documentId: snapshot.documentId
+        });
+      }
+      strapi2.log.info(`[Snapshot] Cleaned up ${toDelete.length} old snapshots for ${roomId}`);
+      return { deleted: toDelete.length };
+    } catch (error) {
+      strapi2.log.error("[Snapshot] Error cleaning up snapshots:", error);
+      throw error;
+    }
+  }
+});
+const name = "magic-editor-x";
+const version = "1.0.1";
+const description = "Advanced block-based editor for Strapi v5 with Editor.js, Media Library integration, and real-time collaboration support";
+const keywords = [
+  "strapi",
+  "plugin",
+  "editor-js",
+  "wysiwyg",
+  "block-editor",
+  "strapi-v5"
+];
+const type = "commonjs";
+const exports$1 = {
+  "./package.json": "./package.json",
+  "./strapi-admin": {
+    source: "./admin/src/index.js",
+    "import": "./dist/admin/index.mjs",
+    require: "./dist/admin/index.js",
+    "default": "./dist/admin/index.js"
+  },
+  "./strapi-server": {
+    source: "./server/src/index.js",
+    "import": "./dist/server/index.mjs",
+    require: "./dist/server/index.js",
+    "default": "./dist/server/index.js"
+  }
+};
+const files = [
+  "dist",
+  "README.md",
+  "LICENSE",
+  "pics"
+];
+const scripts = {
+  build: "strapi-plugin build",
+  watch: "strapi-plugin watch",
+  "watch:link": "strapi-plugin watch:link",
+  verify: "strapi-plugin verify"
+};
+const dependencies = {
+  "@calumk/editorjs-codeflask": "^1.0.10",
+  "@editorjs/attaches": "^1.3.0",
+  "@editorjs/checklist": "^1.6.0",
+  "@editorjs/code": "^2.9.3",
+  "@editorjs/delimiter": "^1.4.2",
+  "@editorjs/editorjs": "^2.31.0",
+  "@editorjs/embed": "^2.7.6",
+  "@editorjs/header": "^2.8.8",
+  "@editorjs/image": "^2.10.1",
+  "@editorjs/inline-code": "^1.5.1",
+  "@editorjs/link": "^2.6.2",
+  "@editorjs/marker": "^1.4.0",
+  "@editorjs/nested-list": "^1.4.3",
+  "@editorjs/paragraph": "^2.11.6",
+  "@editorjs/personality": "^2.0.2",
+  "@editorjs/quote": "^2.7.2",
+  "@editorjs/raw": "^2.5.0",
+  "@editorjs/simple-image": "^1.6.0",
+  "@editorjs/table": "^2.4.2",
+  "@editorjs/text-variant-tune": "^1.0.2",
+  "@editorjs/underline": "^1.1.0",
+  "@editorjs/warning": "^1.4.0",
+  "@heroicons/react": "^2.2.0",
+  "@sotaproject/strikethrough": "^1.0.1",
+  "editorjs-alert": "^1.1.4",
+  "editorjs-drag-drop": "^1.1.16",
+  "editorjs-indent-tune": "^1.4.3",
+  "editorjs-text-alignment-blocktune": "^1.0.3",
+  "editorjs-toggle-block": "^0.3.16",
+  "editorjs-tooltip": "^1.2.2",
+  "editorjs-undo": "^2.0.28",
+  "open-graph-scraper": "^6.8.3",
+  prismjs: "^1.30.0",
+  "socket.io": "^4.8.1",
+  "socket.io-client": "^4.8.1",
+  "y-indexeddb": "^9.0.12",
+  "y-socket.io": "^1.1.3",
+  yjs: "^13.6.15"
+};
+const devDependencies = {
+  "@semantic-release/changelog": "^6.0.3",
+  "@semantic-release/commit-analyzer": "^13.0.0",
+  "@semantic-release/git": "^10.0.1",
+  "@semantic-release/github": "^11.0.1",
+  "@semantic-release/npm": "^12.0.1",
+  "@semantic-release/release-notes-generator": "^14.0.1",
+  "@strapi/design-system": "^2.0.0-rc.30",
+  "@strapi/icons": "^2.0.0-rc.30",
+  "@strapi/sdk-plugin": "^5.3.2",
+  "@strapi/strapi": "^5.31.2",
+  prettier: "^3.7.3",
+  react: "^18.3.1",
+  "react-dom": "^18.3.1",
+  "react-router-dom": "^6.30.2",
+  "semantic-release": "^25.0.2",
+  "styled-components": "^6.1.19"
+};
+const peerDependencies = {
+  "@strapi/sdk-plugin": "^5.3.2",
+  "@strapi/strapi": "^5.31.2",
+  react: "^18.3.1",
+  "react-dom": "^18.3.1",
+  "react-router-dom": "^6.30.2",
+  "styled-components": "^6.1.19"
+};
+const overrides = {
+  prismjs: "^1.30.0"
+};
+const strapi = {
+  kind: "plugin",
+  name: "magic-editor-x",
+  displayName: "Magic Editor X",
+  description: "Advanced block-based editor with Editor.js for Strapi v5"
+};
+const license = "MIT";
+const author = "Schero D. <schero1894@gmail.com>";
+const repository = {
+  type: "git",
+  url: "https://github.com/Schero94/magic-editor-x.git"
+};
+const require$$2 = {
+  name,
+  version,
+  description,
+  keywords,
+  type,
+  exports: exports$1,
+  files,
+  scripts,
+  dependencies,
+  devDependencies,
+  peerDependencies,
+  overrides,
+  strapi,
+  license,
+  author,
+  repository
+};
+const crypto = require$$0$1;
+const os = require$$1$2;
+const LICENSE_SERVER_URL = "https://magicapi.fitlex.me";
+const PLUGIN_NAME = "magic-editor-x";
+const PRODUCT_NAME = "Magic Editor X - Collaborative Editor";
+const TIERS = {
+  free: {
+    name: "FREE",
+    maxCollaborators: 2,
+    features: {
+      editor: true,
+      allTools: true,
+      collaboration: true,
+      ai: false
+    }
+  },
+  premium: {
+    name: "PREMIUM",
+    maxCollaborators: 10,
+    features: {
+      editor: true,
+      allTools: true,
+      collaboration: true,
+      ai: true
+    }
+  },
+  advanced: {
+    name: "ADVANCED",
+    maxCollaborators: -1,
+    // Unlimited
+    features: {
+      editor: true,
+      allTools: true,
+      collaboration: true,
+      ai: true
+    }
+  },
+  enterprise: {
+    name: "ENTERPRISE",
+    maxCollaborators: -1,
+    // Unlimited
+    features: {
+      editor: true,
+      allTools: true,
+      collaboration: true,
+      ai: true,
+      prioritySupport: true
+    }
+  }
+};
+var licenseService$1 = ({ strapi: strapi2 }) => ({
+  /**
+   * Get license server URL
+   * @returns {string} License server URL
+   */
+  getLicenseServerUrl() {
+    return LICENSE_SERVER_URL;
+  },
+  /**
+   * Generate unique device ID based on hardware
+   * @returns {string} 32-character device ID
+   */
+  generateDeviceId() {
+    try {
+      const networkInterfaces = os.networkInterfaces();
+      const macAddresses = [];
+      Object.values(networkInterfaces).forEach((interfaces) => {
+        interfaces?.forEach((iface) => {
+          if (iface.mac && iface.mac !== "00:00:00:00:00:00") {
+            macAddresses.push(iface.mac);
+          }
+        });
+      });
+      const identifier = `${macAddresses.join("-")}-${os.hostname()}`;
+      return crypto.createHash("sha256").update(identifier).digest("hex").substring(0, 32);
+    } catch (error) {
+      return crypto.randomBytes(16).toString("hex");
+    }
+  },
+  /**
+   * Get device hostname
+   * @returns {string} Device name
+   */
+  getDeviceName() {
+    try {
+      return os.hostname() || "Unknown Device";
+    } catch (error) {
+      return "Unknown Device";
+    }
+  },
+  /**
+   * Get external IP address
+   * @returns {string} IP address
+   */
+  getIpAddress() {
+    try {
+      const networkInterfaces = os.networkInterfaces();
+      for (const name2 of Object.keys(networkInterfaces)) {
+        const interfaces = networkInterfaces[name2];
+        if (interfaces) {
+          for (const iface of interfaces) {
+            if (iface.family === "IPv4" && !iface.internal) {
+              return iface.address;
+            }
+          }
+        }
+      }
+      return "127.0.0.1";
+    } catch (error) {
+      return "127.0.0.1";
+    }
+  },
+  /**
+   * Get user agent string for license requests
+   * @returns {string} User agent
+   */
+  getUserAgent() {
+    try {
+      const pluginPkg = require$$2;
+      const pluginVersion = pluginPkg.version || "1.0.0";
+      const strapiVersion = strapi2.config.get("info.strapi") || "5.0.0";
+      return `MagicEditorX/${pluginVersion} Strapi/${strapiVersion} Node/${process.version} ${os.platform()}/${os.release()}`;
+    } catch (error) {
+      return `MagicEditorX/1.0.0 Node/${process.version}`;
+    }
+  },
+  /**
+   * Create a new license
+   * @param {object} params - License parameters
+   * @param {string} params.email - User email
+   * @param {string} params.firstName - User first name
+   * @param {string} params.lastName - User last name
+   * @returns {Promise<object|null>} Created license or null
+   */
+  async createLicense({ email, firstName, lastName }) {
+    try {
+      const deviceId = this.generateDeviceId();
+      const deviceName = this.getDeviceName();
+      const ipAddress = this.getIpAddress();
+      const userAgent = this.getUserAgent();
+      const response = await fetch(`${LICENSE_SERVER_URL}/api/licenses/create`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          email,
+          firstName,
+          lastName,
+          deviceName,
+          deviceId,
+          ipAddress,
+          userAgent,
+          pluginName: PLUGIN_NAME,
+          productName: PRODUCT_NAME
+        })
+      });
+      const data = await response.json();
+      if (data.success) {
+        strapi2.log.info(`[Magic Editor X] [SUCCESS] License created: ${data.data.licenseKey}`);
+        return data.data;
+      } else {
+        strapi2.log.error("[Magic Editor X] [ERROR] License creation failed:", data);
+        return null;
+      }
+    } catch (error) {
+      strapi2.log.error("[Magic Editor X] [ERROR] Error creating license:", error);
+      return null;
+    }
+  },
+  /**
+   * Verify a license key
+   * @param {string} licenseKey - License key to verify
+   * @param {boolean} allowGracePeriod - Allow offline grace period
+   * @returns {Promise<object>} Verification result
+   */
+  async verifyLicense(licenseKey, allowGracePeriod = false) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5e3);
+      const response = await fetch(`${LICENSE_SERVER_URL}/api/licenses/verify`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          licenseKey,
+          pluginName: PLUGIN_NAME,
+          productName: PRODUCT_NAME
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const data = await response.json();
+      if (data.success && data.data) {
+        return { valid: true, data: data.data, gracePeriod: false };
+      } else {
+        return { valid: false, data: null };
+      }
+    } catch (error) {
+      if (allowGracePeriod) {
+        strapi2.log.warn("[Magic Editor X] [WARNING] License verification timeout - grace period active");
+        return { valid: true, data: null, gracePeriod: true };
+      }
+      strapi2.log.error("[Magic Editor X] [ERROR] License verification error:", error.message);
+      return { valid: false, data: null };
+    }
+  },
+  /**
+   * Get license details by key
+   * @param {string} licenseKey - License key
+   * @returns {Promise<object|null>} License data or null
+   */
+  async getLicenseByKey(licenseKey) {
+    try {
+      const response = await fetch(`${LICENSE_SERVER_URL}/api/licenses/key/${licenseKey}`, {
+        method: "GET",
+        headers: { "Content-Type": "application/json" }
+      });
+      const data = await response.json();
+      if (data.success && data.data) {
+        return data.data;
+      }
+      return null;
+    } catch (error) {
+      strapi2.log.error("[Magic Editor X] Error fetching license by key:", error);
+      return null;
+    }
+  },
+  /**
+   * Ping license server to update online status
+   * @param {string} licenseKey - License key
+   * @returns {Promise<object|null>} Ping result or null
+   */
+  async pingLicense(licenseKey) {
+    try {
+      const deviceId = this.generateDeviceId();
+      const deviceName = this.getDeviceName();
+      const ipAddress = this.getIpAddress();
+      const userAgent = this.getUserAgent();
+      const response = await fetch(`${LICENSE_SERVER_URL}/api/licenses/ping`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          licenseKey,
+          deviceId,
+          deviceName,
+          ipAddress,
+          userAgent,
+          pluginName: PLUGIN_NAME
+        })
+      });
+      const data = await response.json();
+      return data.success ? data.data : null;
+    } catch (error) {
+      return null;
+    }
+  },
+  /**
+   * Store license key in plugin store
+   * @param {string} licenseKey - License key to store
+   */
+  async storeLicenseKey(licenseKey) {
+    const pluginStore = strapi2.store({
+      type: "plugin",
+      name: "magic-editor-x"
+    });
+    await pluginStore.set({ key: "licenseKey", value: licenseKey });
+    strapi2.log.info(`[Magic Editor X] [SUCCESS] License key stored: ${licenseKey.substring(0, 8)}...`);
+  },
+  /**
+   * Get stored license key
+   * @returns {Promise<string|null>} License key or null
+   */
+  async getStoredLicenseKey() {
+    const pluginStore = strapi2.store({
+      type: "plugin",
+      name: "magic-editor-x"
+    });
+    return await pluginStore.get({ key: "licenseKey" });
+  },
+  /**
+   * Start automatic license pinging
+   * @param {string} licenseKey - License key
+   * @param {number} intervalMinutes - Ping interval in minutes
+   * @returns {NodeJS.Timeout} Interval handle
+   */
+  startPinging(licenseKey, intervalMinutes = 15) {
+    this.pingLicense(licenseKey);
+    const interval = setInterval(async () => {
+      try {
+        await this.pingLicense(licenseKey);
+      } catch (error) {
+      }
+    }, intervalMinutes * 60 * 1e3);
+    return interval;
+  },
+  /**
+   * Get current license data from store and server
+   * @returns {Promise<object|null>} License data or null
+   */
+  async getCurrentLicense() {
+    try {
+      const licenseKey = await this.getStoredLicenseKey();
+      if (!licenseKey) {
+        return null;
+      }
+      const license2 = await this.getLicenseByKey(licenseKey);
+      return license2;
+    } catch (error) {
+      strapi2.log.error(`[Magic Editor X] [ERROR] Error loading license:`, error);
+      return null;
+    }
+  },
+  /**
+   * Get current tier based on license
+   * @returns {Promise<string>} Tier name (free, premium, advanced, enterprise)
+   */
+  async getCurrentTier() {
+    const license2 = await this.getCurrentLicense();
+    if (!license2) {
+      return "free";
+    }
+    if (license2.featureEnterprise === true) return "enterprise";
+    if (license2.featureAdvanced === true) return "advanced";
+    if (license2.featurePremium === true) return "premium";
+    return "free";
+  },
+  /**
+   * Get tier configuration
+   * @param {string} tierName - Tier name
+   * @returns {object} Tier configuration
+   */
+  getTierConfig(tierName) {
+    return TIERS[tierName] || TIERS.free;
+  },
+  /**
+   * Get maximum allowed collaborators for current license
+   * @returns {Promise<number>} Max collaborators (-1 for unlimited)
+   */
+  async getMaxCollaborators() {
+    const tier = await this.getCurrentTier();
+    const config2 = this.getTierConfig(tier);
+    return config2.maxCollaborators;
+  },
+  /**
+   * Check if a specific feature is available
+   * @param {string} featureName - Feature name
+   * @returns {Promise<boolean>} Feature availability
+   */
+  async hasFeature(featureName) {
+    const tier = await this.getCurrentTier();
+    const config2 = this.getTierConfig(tier);
+    return config2.features[featureName] === true;
+  },
+  /**
+   * Check if user can add more collaborators
+   * @returns {Promise<object>} Check result with canAdd and current/max counts
+   */
+  async canAddCollaborator() {
+    const maxCollaborators = await this.getMaxCollaborators();
+    const currentCount = await strapi2.documents("plugin::magic-editor-x.collab-permission").count();
+    const canAdd = maxCollaborators === -1 || currentCount < maxCollaborators;
+    return {
+      canAdd,
+      current: currentCount,
+      max: maxCollaborators,
+      unlimited: maxCollaborators === -1
+    };
+  },
+  /**
+   * Initialize license service on plugin startup
+   * @returns {Promise<object>} Initialization result
+   */
+  async initialize() {
+    try {
+      strapi2.log.info("[Magic Editor X] [INIT] Initializing License Service...");
+      const licenseKey = await this.getStoredLicenseKey();
+      if (!licenseKey) {
+        strapi2.log.info("[Magic Editor X] [FREE] No license found - Running in FREE mode (2 Collaborators)");
+        return {
+          valid: false,
+          demo: true,
+          tier: "free",
+          data: null
+        };
+      }
+      const pluginStore = strapi2.store({
+        type: "plugin",
+        name: "magic-editor-x"
+      });
+      const lastValidated = await pluginStore.get({ key: "lastValidated" });
+      const now = /* @__PURE__ */ new Date();
+      const gracePeriodHours = 24;
+      let withinGracePeriod = false;
+      if (lastValidated) {
+        const lastValidatedDate = new Date(lastValidated);
+        const hoursSinceValidation = (now.getTime() - lastValidatedDate.getTime()) / (1e3 * 60 * 60);
+        withinGracePeriod = hoursSinceValidation < gracePeriodHours;
+      }
+      const verification = await this.verifyLicense(licenseKey, withinGracePeriod);
+      if (verification.valid) {
+        const license2 = await this.getLicenseByKey(licenseKey);
+        const tier = await this.getCurrentTier();
+        const tierConfig = this.getTierConfig(tier);
+        await pluginStore.set({
+          key: "lastValidated",
+          value: now.toISOString()
+        });
+        const pingInterval = this.startPinging(licenseKey, 15);
+        strapi2.licenseGuardEditorX = {
+          licenseKey,
+          pingInterval,
+          data: verification.data,
+          tier
+        };
+        strapi2.log.info("==================================================================");
+        strapi2.log.info("[SUCCESS] MAGIC EDITOR X LICENSE ACTIVE");
+        strapi2.log.info(`  License: ${licenseKey.substring(0, 15)}...`);
+        strapi2.log.info(`  Tier: ${tierConfig.name}`);
+        strapi2.log.info(`  Collaborators: ${tierConfig.maxCollaborators === -1 ? "Unlimited" : tierConfig.maxCollaborators}`);
+        strapi2.log.info(`  User: ${license2?.firstName} ${license2?.lastName}`);
+        strapi2.log.info("==================================================================");
+        return {
+          valid: true,
+          demo: false,
+          tier,
+          data: verification.data,
+          gracePeriod: verification.gracePeriod || false
+        };
+      } else {
+        strapi2.log.warn("[Magic Editor X] [WARNING] License validation failed - Running in FREE mode");
+        return {
+          valid: false,
+          demo: true,
+          tier: "free",
+          error: "Invalid or expired license",
+          data: null
+        };
+      }
+    } catch (error) {
+      strapi2.log.error("[Magic Editor X] [ERROR] Error initializing License Service:", error);
+      return {
+        valid: false,
+        demo: true,
+        tier: "free",
+        error: error.message,
+        data: null
+      };
+    }
+  }
+});
+const editorService = editorService$1;
+const realtimeService = realtimeService$1;
+const accessService = accessService$1;
+const snapshotService = snapshotService$1;
+const licenseService = licenseService$1;
+var services$1 = {
+  editorService,
+  realtimeService,
+  accessService,
+  snapshotService,
+  licenseService
+};
+const bootstrap = bootstrap$1;
+const destroy = destroy$1;
+const register = register$1;
+const config = config$1;
+const contentTypes = contentTypes$1;
+const controllers = controllers$1;
+const middlewares = middlewares$1;
+const policies = policies$1;
+const routes = routes$1;
+const services = services$1;
+var src = {
+  bootstrap,
+  destroy,
+  register,
+  config,
+  controllers,
+  contentTypes,
+  middlewares,
+  policies,
+  routes,
+  services
+};
+const index = /* @__PURE__ */ getDefaultExportFromCjs(src);
+export {
+  index as default
+};