@localazy/strapi-plugin 1.0.11 → 1.1.1

package/dist/server/index.mjs

@@ -20519,7 +20519,7 @@ var distExports = dist$1.exports;
 const io = /* @__PURE__ */ getDefaultExportFromCjs(distExports);
 const { Server: Server2, Namespace, Socket: Socket3 } = io;
 const name = "@localazy/strapi-plugin";
-const version = "1.0.11";
+const version = "1.1.1";
 const description = "The official Strapi Plugin by Localazy.";
 const keywords = [
   "strapi",
@@ -20580,11 +20580,12 @@ const scripts = {
   "test:server": "jest --config server/jest.config.ts",
   "test:server:coverage": "jest --config server/jest.config.ts --coverage",
   "test:server:watch": "jest --config server/jest.config.ts --watch",
-  "test:ts:back": "run -T tsc -p server/tsconfig.json",
-  "test:ts:front": "run -T tsc -p admin/tsconfig.json",
+  "test:ts:back": "tsc -p server/tsconfig.json --noEmit",
+  "test:ts:front": "tsc -p admin/tsconfig.json --noEmit",
   verify: "strapi-plugin verify",
   watch: "strapi-plugin watch",
-  "watch:link": "strapi-plugin watch:link"
+  "watch:link": "strapi-plugin watch:link",
+  prepare: "husky"
 };
 const dependencies = {
   shelljs: "^0.8.5",
@@ -20716,7 +20717,7 @@ const bootstrap = ({ strapi: strapi2 }) => {
     });
   }
 };
-const destroy = ({ strapi: strapi2 }) => {
+const destroy = ({ strapi: _strapi }) => {
 };
 const isoStrapiToLocalazy = (isoStrapi) => {
   if (!isoStrapi) {
@@ -21874,6 +21875,100 @@ const pickEntries = (flatten, pickPaths) => {
   });
   return pickedEntries;
 };
+const getCharacterLimitsMetadata = (flattenedContent, modelUid) => {
+  const metadata = {};
+  const model = strapi.contentTypes[modelUid] || strapi.components[modelUid];
+  if (!model) {
+    return metadata;
+  }
+  for (const flatKey of Object.keys(flattenedContent)) {
+    const maxLength = resolveMaxLength(flatKey, modelUid, model);
+    if (maxLength != null) {
+      metadata[`@meta:${flatKey}`] = { limit: maxLength };
+    }
+  }
+  return metadata;
+};
+const resolveMaxLength = (flatKey, modelUid, model) => {
+  if (!flatKey.startsWith(`${modelUid}[`)) {
+    return void 0;
+  }
+  const afterUid = flatKey.substring(modelUid.length);
+  const closingBracket = afterUid.indexOf("]");
+  if (closingBracket === -1) {
+    return void 0;
+  }
+  const withoutDocId = afterUid.substring(closingBracket + 2);
+  if (!withoutDocId) {
+    return void 0;
+  }
+  const allParts = withoutDocId.split(".");
+  const fieldPath = parseFieldPath(allParts);
+  if (fieldPath.length === 0) {
+    return void 0;
+  }
+  return walkSchemaForMaxLength(fieldPath, model);
+};
+const parseFieldPath = (parts) => {
+  const segments = [];
+  let i2 = 0;
+  while (i2 < parts.length) {
+    const part = parts[i2];
+    const dynamicZoneMatch = part.match(/^([^[]+)\[(\d+);(.+)$/);
+    if (dynamicZoneMatch) {
+      let componentName = dynamicZoneMatch[3];
+      i2++;
+      while (i2 < parts.length && !parts[i2].includes("]")) {
+        componentName += "." + parts[i2];
+        i2++;
+      }
+      if (i2 < parts.length && parts[i2].includes("]")) {
+        componentName += "." + parts[i2].replace("]", "");
+        i2++;
+      }
+      segments.push({ name: dynamicZoneMatch[1], dynamicZoneComponent: componentName });
+      continue;
+    }
+    const bracketMatch = part.match(/^([^[]+)\[/);
+    if (bracketMatch) {
+      segments.push({ name: bracketMatch[1] });
+      i2++;
+      continue;
+    }
+    segments.push({ name: part });
+    i2++;
+  }
+  return segments;
+};
+const walkSchemaForMaxLength = (fieldPath, model) => {
+  let currentModel = model;
+  for (let i2 = 0; i2 < fieldPath.length; i2++) {
+    const segment = fieldPath[i2];
+    const attribute = currentModel?.attributes?.[segment.name];
+    if (!attribute) {
+      return void 0;
+    }
+    if (i2 === fieldPath.length - 1) {
+      return attribute.maxLength;
+    }
+    if (attribute.type === "component" && attribute.component) {
+      currentModel = strapi.components[attribute.component];
+      if (!currentModel) {
+        return void 0;
+      }
+      continue;
+    }
+    if (attribute.type === "dynamiczone" && segment.dynamicZoneComponent) {
+      currentModel = strapi.components[segment.dynamicZoneComponent];
+      if (!currentModel) {
+        return void 0;
+      }
+      continue;
+    }
+    return void 0;
+  }
+  return void 0;
+};
 const getMainKeysOfNestedArrayObjects = (array) => {
   return array.map((item) => Reflect.ownKeys(item)[0]);
 };
@@ -21968,6 +22063,9 @@ const getLocalazyUploadService = () => {
 const getEntryExclusionService = () => {
   return strapi.plugin(PLUGIN_NAME).service("EntryExclusionService");
 };
+const getActivityLogsService = () => {
+  return strapi.plugin(PLUGIN_NAME).service("ActivityLogsService");
+};
 class PluginSettingsServiceHelper {
   constructor() {
     this.PluginSettingsService = getPluginSettingsService();
@@ -22146,8 +22244,13 @@ const getPickedFlattenKeysForHookEntry = async (params) => {
     };
   }
   const pickedFlatten = pickEntries(flatten, pickPathsWithUid);
+  const characterLimitsMetadata = getCharacterLimitsMetadata(pickedFlatten, modelUid);
+  const pickedFlattenWithMetadata = {
+    ...pickedFlatten,
+    ...characterLimitsMetadata
+  };
   return {
-    pickedFlatten,
+    pickedFlatten: pickedFlattenWithMetadata,
     eventEntryLocale,
     projectSourceLanguageCode
   };
@@ -23969,7 +24072,7 @@ const register = ({ strapi: strapi2 }) => {
   });
 };
 const contentTypes = {};
-const LocalazyUserController = ({ strapi: strapi2 }) => ({
+const LocalazyUserController = ({ strapi: _strapi }) => ({
   async getUser(ctx) {
     ctx.body = await getLocalazyUserService().getUser();
   },
@@ -24067,7 +24170,7 @@ const LocalazyGenericConnectorClientFactory = async () => {
   });
   return api;
 };
-const LocalazyAuthController = ({ strapi: strapi2 }) => ({
+const LocalazyAuthController = ({ strapi: _strapi }) => ({
   async generateKeys(ctx) {
     const GenericConnectorApi = await LocalazyGenericConnectorClientFactory();
     ctx.body = await GenericConnectorApi.public.keys();
@@ -24094,10 +24197,12 @@ const StrapiController = ({ strapi: strapi2 }) => ({
   },
   async getPluginVersion(ctx) {
     ctx.body = {
-      version: await getStrapiService().getPluginVersion()
+      version: await getStrapiService().getPluginVersion(),
+      versionStrapi: getStrapiService().getStrapiVersion()
     };
   }
 });
+const STRAPI_WEBHOOK_CUSTOM_ID = "strapi-plugin-localazy";
 const LocalazyProjectController = ({ strapi: strapi2 }) => ({
   async getConnectedProject(ctx) {
     const LocalazyUserService2 = getLocalazyUserService();
@@ -24105,9 +24210,69 @@ const LocalazyProjectController = ({ strapi: strapi2 }) => ({
     const user = await LocalazyUserService2.getUser();
     const project = await LocalazyPubAPIService2.getProject(user.project.id, true, true);
     ctx.body = project;
+  },
+  async getWebhookStatus(ctx) {
+    const LocalazyUserService2 = getLocalazyUserService();
+    const user = await LocalazyUserService2.getUser();
+    const LocalazyPubApiService = getLocalazyPubAPIService();
+    const webhooks = await LocalazyPubApiService.listWebhooks(user.project.id);
+    const ours = webhooks.find((w2) => w2.customId === STRAPI_WEBHOOK_CUSTOM_ID);
+    if (ours) {
+      ctx.body = { status: "configured", url: ours.url, enabled: ours.enabled };
+      return;
+    }
+    ctx.body = { status: "not_configured" };
+  },
+  async setupWebhook(ctx) {
+    const { url: url2 } = ctx.request.body;
+    if (!url2 || typeof url2 !== "string") {
+      return ctx.badRequest("Webhook URL is required");
+    }
+    try {
+      const parsed = new URL(url2);
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        return ctx.badRequest("Webhook URL must use http or https protocol");
+      }
+    } catch {
+      return ctx.badRequest("Invalid webhook URL");
+    }
+    const LocalazyUserService2 = getLocalazyUserService();
+    const user = await LocalazyUserService2.getUser();
+    const LocalazyPubApiService = getLocalazyPubAPIService();
+    const PluginSettingsService2 = getPluginSettingsService();
+    const existing = await LocalazyPubApiService.listWebhooks(user.project.id);
+    const filtered = existing.filter((w2) => w2.customId !== STRAPI_WEBHOOK_CUSTOM_ID);
+    const items = [
+      ...filtered,
+      {
+        enabled: true,
+        customId: STRAPI_WEBHOOK_CUSTOM_ID,
+        url: url2,
+        events: ["project_published"],
+        description: "Strapi Plugin - Download translations"
+      }
+    ];
+    await LocalazyPubApiService.updateWebhooks(user.project.id, items);
+    await PluginSettingsService2.updatePluginSettings({
+      webhookConfig: { url: url2 }
+    });
+    ctx.body = { success: true };
+  },
+  async getStrapiUrl(ctx) {
+    let url2 = strapi2.config.get("server.url");
+    if (!url2) {
+      const host = strapi2.config.get("server.host") || "0.0.0.0";
+      const port = strapi2.config.get("server.port") || 1337;
+      const displayHost = host === "0.0.0.0" || host === "::" ? "localhost" : host;
+      url2 = `http://${displayHost}:${port}`;
+    }
+    const isLocal = /^https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0|10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.)/.test(
+      url2
+    );
+    ctx.body = { url: url2, isLocal };
   }
 });
-const PluginSettingsController = ({ strapi: strapi2 }) => ({
+const PluginSettingsController = ({ strapi: _strapi }) => ({
   async getContentTransferSetup(ctx) {
     ctx.body = await getPluginSettingsService().getContentTransferSetup();
   },
@@ -24302,6 +24467,27 @@ const EntryExclusionController = ({ strapi: strapi2 }) => ({
     }
   }
 });
+const ActivityLogsController = ({ strapi: _strapi }) => ({
+  async getSessions(ctx) {
+    const { type: type2 } = ctx.query;
+    ctx.body = await getActivityLogsService().getSessions(type2);
+  },
+  async getSession(ctx) {
+    const { sessionId } = ctx.params;
+    const session = await getActivityLogsService().getSession(sessionId);
+    if (!session) {
+      return ctx.notFound("Session not found");
+    }
+    ctx.body = session;
+  },
+  async exportSessions(ctx) {
+    ctx.body = await getActivityLogsService().getAllSessionsWithEntries();
+  },
+  async clearSessions(ctx) {
+    await getActivityLogsService().clearSessions();
+    ctx.body = { success: true };
+  }
+});
 const controllers = {
   LocalazyUserController,
   LocalazyAuthController,
@@ -24309,7 +24495,8 @@ const controllers = {
   LocalazyProjectController,
   PluginSettingsController,
   LocalazyTransferController,
-  EntryExclusionController
+  EntryExclusionController,
+  ActivityLogsController
 };
 const verifyWebhook = (config2, { strapi: strapi2 }) => {
   return async (ctx, next) => {
@@ -24366,11 +24553,11 @@ const middlewares = {
   verifyWebhook
 };
 const policies = {};
-const ROUTE_PREFIX$7 = "/user";
+const ROUTE_PREFIX$8 = "/user";
 const LocalazyUserRoutes = [
   {
     method: "GET",
-    path: `${ROUTE_PREFIX$7}`,
+    path: `${ROUTE_PREFIX$8}`,
     handler: "LocalazyUserController.getUser",
     config: {
       policies: []
@@ -24378,7 +24565,7 @@ const LocalazyUserRoutes = [
   },
   {
     method: "PUT",
-    path: `${ROUTE_PREFIX$7}`,
+    path: `${ROUTE_PREFIX$8}`,
     handler: "LocalazyUserController.updateUser",
     config: {
       policies: []
@@ -24386,18 +24573,18 @@ const LocalazyUserRoutes = [
   },
   {
     method: "DELETE",
-    path: `${ROUTE_PREFIX$7}`,
+    path: `${ROUTE_PREFIX$8}`,
     handler: "LocalazyUserController.deleteUser",
     config: {
       policies: []
     }
   }
 ];
-const ROUTE_PREFIX$6 = "/auth";
+const ROUTE_PREFIX$7 = "/auth";
 const LocalazyAuthRoutes = [
   {
     method: "GET",
-    path: `${ROUTE_PREFIX$6}/generate-keys`,
+    path: `${ROUTE_PREFIX$7}/generate-keys`,
     handler: "LocalazyAuthController.generateKeys",
     config: {
       policies: []
@@ -24405,18 +24592,18 @@ const LocalazyAuthRoutes = [
   },
   {
     method: "GET",
-    path: `${ROUTE_PREFIX$6}/continuous-poll`,
+    path: `${ROUTE_PREFIX$7}/continuous-poll`,
     handler: "LocalazyAuthController.continuousPoll",
     config: {
       policies: []
     }
   }
 ];
-const ROUTE_PREFIX$5 = "/plugin-settings";
+const ROUTE_PREFIX$6 = "/plugin-settings";
 const PluginSettingsRoutes = [
   {
     method: "GET",
-    path: `${ROUTE_PREFIX$5}/content-transfer-setup`,
+    path: `${ROUTE_PREFIX$6}/content-transfer-setup`,
     handler: "PluginSettingsController.getContentTransferSetup",
     config: {
       policies: []
@@ -24424,7 +24611,7 @@ const PluginSettingsRoutes = [
   },
   {
     method: "PUT",
-    path: `${ROUTE_PREFIX$5}/content-transfer-setup`,
+    path: `${ROUTE_PREFIX$6}/content-transfer-setup`,
     handler: "PluginSettingsController.updateContentTransferSetup",
     config: {
       policies: []
@@ -24432,7 +24619,7 @@ const PluginSettingsRoutes = [
   },
   {
     method: "GET",
-    path: `${ROUTE_PREFIX$5}/plugin-settings`,
+    path: `${ROUTE_PREFIX$6}/plugin-settings`,
     handler: "PluginSettingsController.getPluginSettings",
     config: {
       policies: []
@@ -24440,7 +24627,7 @@ const PluginSettingsRoutes = [
   },
   {
     method: "PUT",
-    path: `${ROUTE_PREFIX$5}/plugin-settings`,
+    path: `${ROUTE_PREFIX$6}/plugin-settings`,
     handler: "PluginSettingsController.updatePluginSettings",
     config: {
       policies: []
@@ -24448,18 +24635,18 @@ const PluginSettingsRoutes = [
   },
   {
     method: "GET",
-    path: `${ROUTE_PREFIX$5}/sync-cursor`,
+    path: `${ROUTE_PREFIX$6}/sync-cursor`,
     handler: "PluginSettingsController.getSyncCursor",
     config: {
       policies: []
     }
   }
 ];
-const ROUTE_PREFIX$4 = "/strapi";
+const ROUTE_PREFIX$5 = "/strapi";
 const StrapiRoutes = [
   {
     method: "GET",
-    path: `${ROUTE_PREFIX$4}/models`,
+    path: `${ROUTE_PREFIX$5}/models`,
     handler: "StrapiController.getModels",
     config: {
       policies: []
@@ -24467,7 +24654,7 @@ const StrapiRoutes = [
   },
   {
     method: "GET",
-    path: `${ROUTE_PREFIX$4}/localizable-models`,
+    path: `${ROUTE_PREFIX$5}/localizable-models`,
     handler: "StrapiController.getLocalizableModels",
     config: {
       policies: []
@@ -24475,7 +24662,7 @@ const StrapiRoutes = [
   },
   {
     method: "POST",
-    path: `${ROUTE_PREFIX$4}/lifecycle/localazy-webhooks`,
+    path: `${ROUTE_PREFIX$5}/lifecycle/localazy-webhooks`,
     handler: "StrapiController.postLifecycleLocalazyWebhooks",
     config: {
       policies: []
@@ -24483,18 +24670,18 @@ const StrapiRoutes = [
   },
   {
     method: "GET",
-    path: `${ROUTE_PREFIX$4}/version`,
+    path: `${ROUTE_PREFIX$5}/version`,
     handler: "StrapiController.getPluginVersion",
     config: {
       policies: []
     }
   }
 ];
-const ROUTE_PREFIX$3 = "/transfer";
+const ROUTE_PREFIX$4 = "/transfer";
 const LocalazyTransferRoutes = [
   {
     method: "POST",
-    path: `${ROUTE_PREFIX$3}/upload`,
+    path: `${ROUTE_PREFIX$4}/upload`,
     handler: "LocalazyTransferController.upload",
     config: {
       policies: []
@@ -24502,29 +24689,53 @@ const LocalazyTransferRoutes = [
   },
   {
     method: "POST",
-    path: `${ROUTE_PREFIX$3}/download`,
+    path: `${ROUTE_PREFIX$4}/download`,
     handler: "LocalazyTransferController.download",
     config: {
       policies: []
     }
   }
 ];
-const ROUTE_PREFIX$2 = "/project";
+const ROUTE_PREFIX$3 = "/project";
 const LocalazyProjectRoutes = [
   {
     method: "GET",
-    path: `${ROUTE_PREFIX$2}`,
+    path: `${ROUTE_PREFIX$3}`,
     handler: "LocalazyProjectController.getConnectedProject",
     config: {
       policies: []
     }
+  },
+  {
+    method: "GET",
+    path: `${ROUTE_PREFIX$3}/webhooks`,
+    handler: "LocalazyProjectController.getWebhookStatus",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "POST",
+    path: `${ROUTE_PREFIX$3}/webhooks/setup`,
+    handler: "LocalazyProjectController.setupWebhook",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: `${ROUTE_PREFIX$3}/strapi-url`,
+    handler: "LocalazyProjectController.getStrapiUrl",
+    config: {
+      policies: []
+    }
   }
 ];
-const ROUTE_PREFIX$1 = "/public/transfer";
+const ROUTE_PREFIX$2 = "/public/transfer";
 const LocalazyPublicTransferRoutes = [
   {
     method: "POST",
-    path: `${ROUTE_PREFIX$1}/download`,
+    path: `${ROUTE_PREFIX$2}/download`,
     handler: "LocalazyTransferController.download",
     config: {
       policies: [],
@@ -24534,11 +24745,11 @@ const LocalazyPublicTransferRoutes = [
     }
   }
 ];
-const ROUTE_PREFIX = "/entry-exclusion";
+const ROUTE_PREFIX$1 = "/entry-exclusion";
 const EntryExclusionRoutes = [
   {
     method: "GET",
-    path: `${ROUTE_PREFIX}/:contentType/:documentId`,
+    path: `${ROUTE_PREFIX$1}/:contentType/:documentId`,
     handler: "EntryExclusionController.getEntryExclusion",
     config: {
       policies: []
@@ -24546,7 +24757,7 @@ const EntryExclusionRoutes = [
   },
   {
     method: "PUT",
-    path: `${ROUTE_PREFIX}/:contentType/:documentId`,
+    path: `${ROUTE_PREFIX$1}/:contentType/:documentId`,
     handler: "EntryExclusionController.setEntryExclusion",
     config: {
       policies: []
@@ -24554,13 +24765,48 @@ const EntryExclusionRoutes = [
   },
   {
     method: "GET",
-    path: `${ROUTE_PREFIX}/:contentType`,
+    path: `${ROUTE_PREFIX$1}/:contentType`,
     handler: "EntryExclusionController.getContentTypeExclusions",
     config: {
       policies: []
     }
   }
 ];
+const ROUTE_PREFIX = "/activity-logs";
+const ActivityLogsRoutes = [
+  {
+    method: "GET",
+    path: `${ROUTE_PREFIX}`,
+    handler: "ActivityLogsController.getSessions",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: `${ROUTE_PREFIX}/export`,
+    handler: "ActivityLogsController.exportSessions",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: `${ROUTE_PREFIX}/:sessionId`,
+    handler: "ActivityLogsController.getSession",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "DELETE",
+    path: `${ROUTE_PREFIX}`,
+    handler: "ActivityLogsController.clearSessions",
+    config: {
+      policies: []
+    }
+  }
+];
 const routes = {
   "content-api": {
     routes: [...StrapiRoutes]
@@ -24574,14 +24820,15 @@ const routes = {
       ...StrapiRoutes,
       ...LocalazyTransferRoutes,
       ...LocalazyProjectRoutes,
-      ...EntryExclusionRoutes
+      ...EntryExclusionRoutes,
+      ...ActivityLogsRoutes
     ]
   },
   LocalazyPublicTransferRoutes: {
     routes: [...LocalazyPublicTransferRoutes]
   }
 };
-const KEY$3 = "identity";
+const KEY$4 = "identity";
 const emptyIdentity = {
   accessToken: "",
   project: {
@@ -24605,13 +24852,13 @@ const getStrapiStore = (strapi2) => strapi2.store({
 const LocalazyUserService = ({ strapi: strapi2 }) => ({
   async getUser() {
     const pluginStore = getStrapiStore(strapi2);
-    const user = await pluginStore.get({ key: KEY$3 });
+    const user = await pluginStore.get({ key: KEY$4 });
     return user || emptyIdentity;
   },
   async updateUser(identity2) {
     const pluginStore = getStrapiStore(strapi2);
     await pluginStore.set({
-      key: KEY$3,
+      key: KEY$4,
       value: identity2
     });
     return identity2;
@@ -24685,6 +24932,9 @@ const StrapiService = ({ strapi: strapi2 }) => ({
   },
   async getPluginVersion() {
     return await Promise.resolve().then(() => _package$1).then((module2) => module2.version);
+  },
+  getStrapiVersion() {
+    return strapi2.config.get("info.strapi");
   }
 });
 const LocalazyPubAPIService = ({ strapi: strapi2 }) => ({
@@ -24727,6 +24977,25 @@ const LocalazyPubAPIService = ({ strapi: strapi2 }) => ({
       return null;
     }
   },
+  async listWebhooks(projectId) {
+    try {
+      const LocalazyApi = await LocalazyApiClientFactory();
+      const result = await LocalazyApi.webhooks.list({ project: projectId });
+      return result;
+    } catch (e2) {
+      strapi2.log.error(e2);
+      return [];
+    }
+  },
+  async updateWebhooks(projectId, items) {
+    try {
+      const LocalazyApi = await LocalazyApiClientFactory();
+      await LocalazyApi.webhooks.update({ project: projectId, items });
+    } catch (e2) {
+      strapi2.log.error(e2);
+      throw e2;
+    }
+  },
   async getWebhooksSecret(projectId) {
     try {
       const LocalazyApi = await LocalazyApiClientFactory();
@@ -24738,23 +25007,23 @@ const LocalazyPubAPIService = ({ strapi: strapi2 }) => ({
     }
   }
 });
-const KEY$2 = "content-transfer-setup";
+const KEY$3 = "content-transfer-setup";
 const emptyContentTransferSetup = {
   has_setup: false,
   setup: []
 };
-const KEY$1 = "plugin-settings";
+const KEY$2 = "plugin-settings";
 const emptyPluginSettings = {
   defaultRoute: null
 };
-const KEY = "sync-cursor";
+const KEY$1 = "sync-cursor";
 const emptySyncCursor = {
   processedKeys: {}
 };
 const PluginSettingsService = ({ strapi: strapi2 }) => ({
   async getContentTransferSetup() {
     const pluginStore = getStrapiStore(strapi2);
-    const setup2 = await pluginStore.get({ key: KEY$2 });
+    const setup2 = await pluginStore.get({ key: KEY$3 });
     return setup2 || emptyContentTransferSetup;
   },
   async updateContentTransferSetup(setup2) {
@@ -24764,14 +25033,14 @@ const PluginSettingsService = ({ strapi: strapi2 }) => ({
     };
     const pluginStore = getStrapiStore(strapi2);
     await pluginStore.set({
-      key: KEY$2,
+      key: KEY$3,
       value: newSetup
     });
     return newSetup;
   },
   async getPluginSettings() {
     const pluginStore = getStrapiStore(strapi2);
-    const settings = await pluginStore.get({ key: KEY$1 });
+    const settings = await pluginStore.get({ key: KEY$2 });
     return settings || emptyPluginSettings;
   },
   async updatePluginSettings(settings) {
@@ -24782,20 +25051,20 @@ const PluginSettingsService = ({ strapi: strapi2 }) => ({
     };
     const pluginStore = getStrapiStore(strapi2);
     await pluginStore.set({
-      key: KEY$1,
+      key: KEY$2,
       value: newSettings
     });
     return newSettings;
   },
   async getSyncCursor() {
     const pluginStore = getStrapiStore(strapi2);
-    const cursor = await pluginStore.get({ key: KEY });
+    const cursor = await pluginStore.get({ key: KEY$1 });
     return cursor || emptySyncCursor;
   },
   async updateSyncCursor(cursor) {
     const pluginStore = getStrapiStore(strapi2);
     await pluginStore.set({
-      key: KEY,
+      key: KEY$1,
       value: cursor
     });
     return cursor;
@@ -24807,6 +25076,9 @@ const LocalazyTransferUploadService = ({ strapi: strapi2 }) => ({
     await notificationService.emit(EventType.UPLOAD, {
       message: "Upload started"
     });
+    const activityLogsService = getActivityLogsService();
+    const sessionId = await activityLogsService.startSession("upload", "Strapi User");
+    await activityLogsService.addEntry(sessionId, "Upload started");
     let success = true;
     const StrapiService2 = getStrapiService();
     const StrapiI18nService2 = getStrapiI18nService();
@@ -24820,6 +25092,8 @@ const LocalazyTransferUploadService = ({ strapi: strapi2 }) => ({
         success,
         message
       });
+      await activityLogsService.addEntry(sessionId, message);
+      await activityLogsService.finishSession(sessionId, "failed", message);
       strapi2.log.info(message);
       return;
     }
@@ -24840,6 +25114,7 @@ const LocalazyTransferUploadService = ({ strapi: strapi2 }) => ({
         await notificationService.emit(EventType.UPLOAD, {
           message: message2
         });
+        await activityLogsService.addEntry(sessionId, message2);
         strapi2.log.info(message2);
         continue;
       }
@@ -24850,6 +25125,7 @@ const LocalazyTransferUploadService = ({ strapi: strapi2 }) => ({
         await notificationService.emit(EventType.UPLOAD, {
           message: message2
         });
+        await activityLogsService.addEntry(sessionId, message2);
         strapi2.log.warn(message2);
         continue;
       }
@@ -24876,6 +25152,7 @@ const LocalazyTransferUploadService = ({ strapi: strapi2 }) => ({
         await notificationService.emit(EventType.UPLOAD, {
           message: message2
         });
+        await activityLogsService.addEntry(sessionId, message2);
         strapi2.log.info(message2);
         continue;
       }
@@ -24883,6 +25160,7 @@ const LocalazyTransferUploadService = ({ strapi: strapi2 }) => ({
       await notificationService.emit(EventType.UPLOAD, {
         message
       });
+      await activityLogsService.addEntry(sessionId, message);
       strapi2.log.info(message);
       entries = omitDeep(entries, ["locale", "createdAt", "updatedAt", "publishedAt"]);
       entries.forEach((entry) => {
@@ -24895,6 +25173,11 @@ const LocalazyTransferUploadService = ({ strapi: strapi2 }) => ({
           ...pickedFlatten
         };
       });
+      const characterLimitsMetadata = getCharacterLimitsMetadata(pickedFlattenStrapiContent, modelUid);
+      pickedFlattenStrapiContent = {
+        ...pickedFlattenStrapiContent,
+        ...characterLimitsMetadata
+      };
     }
     const strapiDefaultLocaleCode = await StrapiI18nService2.getDefaultLocaleCode();
     const localazyLocaleCode = strapiDefaultLocaleCode ? isoStrapiToLocalazy(strapiDefaultLocaleCode) : config.default.LOCALAZY_DEFAULT_LOCALE;
@@ -24915,12 +25198,33 @@ const LocalazyTransferUploadService = ({ strapi: strapi2 }) => ({
     await notificationService.emit(EventType.UPLOAD, {
       message: "Uploading collections to Localazy..."
     });
-    await LocalazyUploadService2.upload(importFile, uploadConfig);
+    await activityLogsService.addEntry(sessionId, "Uploading collections to Localazy...");
+    try {
+      await LocalazyUploadService2.upload(importFile, uploadConfig);
+    } catch (error) {
+      success = false;
+      const errorMessage = `Upload to Localazy failed: ${error instanceof Error ? error.message : String(error)}`;
+      strapi2.log.error(errorMessage);
+      await notificationService.emit(EventType.UPLOAD_FINISHED, {
+        success,
+        message: errorMessage
+      });
+      await activityLogsService.addEntry(sessionId, errorMessage);
+      await activityLogsService.finishSession(sessionId, "failed", errorMessage);
+      console.timeEnd("upload");
+      return;
+    }
     strapi2.log.info("Upload finished in");
     await notificationService.emit(EventType.UPLOAD_FINISHED, {
       success,
       message: "Upload finished"
     });
+    await activityLogsService.addEntry(sessionId, "Upload finished");
+    await activityLogsService.finishSession(
+      sessionId,
+      success ? "completed" : "failed",
+      success ? "Upload completed successfully" : "Upload finished with errors"
+    );
     console.timeEnd("upload");
   }
 });
@@ -25339,6 +25643,12 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
     await notificationService.emit(EventType.DOWNLOAD, {
       message: `Download started (${syncMode})`
     });
+    const activityLogsService = getActivityLogsService();
+    const requestInitiatorHelper = new RequestInitiatorHelper(strapi2);
+    const isWebhook = requestInitiatorHelper.isInitiatedByLocalazyWebhook();
+    const initiatedBy = isWebhook ? "Webhook" : "Strapi User";
+    const sessionId = await activityLogsService.startSession(isWebhook ? "webhook" : "download", initiatedBy);
+    await activityLogsService.addEntry(sessionId, `Download started (${syncMode})`);
     let success = true;
     const StrapiService2 = getStrapiService();
     const StrapiI18nService2 = getStrapiI18nService();
@@ -25357,6 +25667,8 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
         success,
         message
       });
+      await activityLogsService.addEntry(sessionId, message);
+      await activityLogsService.finishSession(sessionId, "failed", message);
       return;
     }
     const project = await LocalazyPubAPIService2.getProject(user.project.id, false, true);
@@ -25368,6 +25680,8 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
         success,
         message
       });
+      await activityLogsService.addEntry(sessionId, message);
+      await activityLogsService.finishSession(sessionId, "failed", message);
       return;
     }
     const projectLanguages = project.languages;
@@ -25381,6 +25695,8 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
         success,
         message
       });
+      await activityLogsService.addEntry(sessionId, message);
+      await activityLogsService.finishSession(sessionId, "failed", message);
       return;
     }
     const projectSourceLanguageCode = sourceLanguage.code;
@@ -25394,6 +25710,8 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
         success,
         message
       });
+      await activityLogsService.addEntry(sessionId, message);
+      await activityLogsService.finishSession(sessionId, "completed", message);
       return;
     }
     let languagesCodes = projectLanguagesWithoutSourceLanguage.map((language3) => language3.code);
@@ -25412,6 +25730,7 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
         await notificationService.emit(EventType.DOWNLOAD, {
           message: `Created locale ${newLocale.code}`
         });
+        await activityLogsService.addEntry(sessionId, `Created locale ${newLocale.code}`);
       } catch (e2) {
         strapi2.log.error(e2.message);
         if (e2.name === "ValidationError") {
@@ -25419,10 +25738,12 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
           await notificationService.emit(EventType.DOWNLOAD, {
             message: `Language ${isoLocalazy} is not supported by Strapi`
           });
+          await activityLogsService.addEntry(sessionId, `Language ${isoLocalazy} is not supported by Strapi`);
         } else {
           await notificationService.emit(EventType.DOWNLOAD, {
             message: e2.message
           });
+          await activityLogsService.addEntry(sessionId, e2.message);
         }
       }
     }
@@ -25447,6 +25768,7 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
         await notificationService.emit(EventType.DOWNLOAD, {
           message: `No keys found for language ${isoLocalazy}`
         });
+        await activityLogsService.addEntry(sessionId, `No keys found for language ${isoLocalazy}`);
       } else {
         const newKeys = langKeys.filter((k2) => {
           const storedEvent = langProcessedKeys[k2.id];
@@ -25455,6 +25777,10 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
         await notificationService.emit(EventType.DOWNLOAD, {
           message: `${syncMode}: ${newKeys.length} changed / ${langKeys.length} total keys for language ${isoLocalazy}`
         });
+        await activityLogsService.addEntry(
+          sessionId,
+          `${syncMode}: ${newKeys.length} changed / ${langKeys.length} total keys for language ${isoLocalazy}`
+        );
       }
       localazyContent[isoLocalazy] = langKeys;
     }
@@ -25583,9 +25909,7 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
               locDownloadPLevel: 6
             });
             if (isEmpty(baseEntry)) {
-              strapi2.log.info(
-                `Source language entry ${uid}[${documentId}] does not exist anymore, skipping...`
-              );
+              strapi2.log.info(`Source language entry ${uid}[${documentId}] does not exist anymore, skipping...`);
               await markKeysProcessed(sourceKeys);
               continue;
             }
@@ -25597,7 +25921,7 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
             const localazySearchUrl = `${user.project.url}/source-language?search=${uid}[${documentId}]`;
             if (isEmpty(currentLanguageLocalizedEntry)) {
               try {
-                const createdEntry = await StrapiLocalazyI18nService2.createEntry(
+                await StrapiLocalazyI18nService2.createEntry(
                   uid,
                   strapiContentTypesModels,
                   translatedModel,
@@ -25609,6 +25933,7 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
                 await notificationService.emit(EventType.DOWNLOAD, {
                   message
                 });
+                await activityLogsService.addEntry(sessionId, message);
                 await markKeysProcessed(sourceKeys);
               } catch (e2) {
                 success = false;
@@ -25621,11 +25946,15 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
                     localazy: localazySearchUrl
                   }
                 });
+                await activityLogsService.addEntry(
+                  sessionId,
+                  `Failed to create ${uid} [${documentId}] in ${isoStrapi}: ${e2.message}`
+                );
               }
             } else {
               try {
                 const localizedDocumentId = currentLanguageLocalizedEntry.documentId;
-                const updatedEntry = await StrapiLocalazyI18nService2.updateEntry(
+                await StrapiLocalazyI18nService2.updateEntry(
                   uid,
                   localizedDocumentId,
                   strapiContentTypesModels,
@@ -25638,6 +25967,7 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
                 await notificationService.emit(EventType.DOWNLOAD, {
                   message
                 });
+                await activityLogsService.addEntry(sessionId, message);
                 await markKeysProcessed(sourceKeys);
               } catch (e2) {
                 success = false;
@@ -25650,6 +25980,10 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
                     localazy: localazySearchUrl
                   }
                 });
+                await activityLogsService.addEntry(
+                  sessionId,
+                  `Failed to update ${uid} [${documentId}] in ${isoStrapi}: ${e2.message}`
+                );
               }
             }
           } catch (e2) {
@@ -25658,11 +25992,18 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
             await notificationService.emit(EventType.DOWNLOAD, {
               message: `Error processing ${uid} [${documentId}] in ${isoStrapi}: ${e2.message}`
             });
+            await activityLogsService.addEntry(
+              sessionId,
+              `Error processing ${uid} [${documentId}] in ${isoStrapi}: ${e2.message}`
+            );
           }
         }
       }
     }
-    const totalProcessedKeys = Object.values(processedKeys).reduce((sum, langKeys) => sum + Object.keys(langKeys).length, 0);
+    const totalProcessedKeys = Object.values(processedKeys).reduce(
+      (sum, langKeys) => sum + Object.keys(langKeys).length,
+      0
+    );
     strapi2.log.info(
       `Download finished. Tracked ${totalProcessedKeys} processed keys across ${Object.keys(processedKeys).length} languages.`
     );
@@ -25670,6 +26011,13 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
       success,
       message: "Download finished"
     });
+    const finishMessage = `Download finished. Tracked ${totalProcessedKeys} processed keys across ${Object.keys(processedKeys).length} languages.`;
+    await activityLogsService.addEntry(sessionId, finishMessage);
+    await activityLogsService.finishSession(
+      sessionId,
+      success ? "completed" : "failed",
+      success ? "Download completed successfully" : "Download finished with errors"
+    );
     console.timeEnd("download");
   }
 });
@@ -26393,6 +26741,112 @@ const EntryExclusionService = ({ strapi: strapi2 }) => ({
     return Object.values(exclusions).filter((exclusion) => exclusion.contentType === contentType && exclusion.excludeFromTranslation).map((exclusion) => exclusion.documentId);
   }
 });
+const KEY = "activity-logs";
+const emptyActivityLogs = {
+  sessions: []
+};
+const ONE_YEAR_MS = 365 * 24 * 60 * 60 * 1e3;
+let writeLock = Promise.resolve();
+const withLock = async (fn) => {
+  let release;
+  const next = new Promise((resolve) => {
+    release = resolve;
+  });
+  const prev2 = writeLock;
+  writeLock = next;
+  await prev2;
+  try {
+    return await fn();
+  } finally {
+    release();
+  }
+};
+const ActivityLogsService = ({ strapi: strapi2 }) => ({
+  async getActivityLogs() {
+    const pluginStore = getStrapiStore(strapi2);
+    const logs = await pluginStore.get({ key: KEY });
+    return logs || { sessions: [] };
+  },
+  async saveActivityLogs(logs) {
+    const pluginStore = getStrapiStore(strapi2);
+    await pluginStore.set({
+      key: KEY,
+      value: logs
+    });
+  },
+  async startSession(eventType, initiatedBy) {
+    return withLock(async () => {
+      const logs = await this.getActivityLogs();
+      const sessionId = generateRandomId();
+      const session = {
+        id: sessionId,
+        eventType,
+        status: "in-progress",
+        startedAt: Date.now(),
+        initiatedBy,
+        summary: "",
+        entries: []
+      };
+      logs.sessions.unshift(session);
+      const cutoff = Date.now() - ONE_YEAR_MS;
+      logs.sessions = logs.sessions.filter((s2) => s2.startedAt >= cutoff);
+      await this.saveActivityLogs(logs);
+      return sessionId;
+    });
+  },
+  async addEntry(sessionId, message, data) {
+    return withLock(async () => {
+      const logs = await this.getActivityLogs();
+      const session = logs.sessions.find((s2) => s2.id === sessionId);
+      if (!session) {
+        return;
+      }
+      const entry = {
+        message,
+        timestamp: Date.now(),
+        data
+      };
+      session.entries.push(entry);
+      await this.saveActivityLogs(logs);
+    });
+  },
+  async finishSession(sessionId, status, summary) {
+    return withLock(async () => {
+      const logs = await this.getActivityLogs();
+      const session = logs.sessions.find((s2) => s2.id === sessionId);
+      if (!session) {
+        return;
+      }
+      session.status = status;
+      session.finishedAt = Date.now();
+      session.summary = summary;
+      await this.saveActivityLogs(logs);
+    });
+  },
+  async getSessions(eventType) {
+    const logs = await this.getActivityLogs();
+    let { sessions } = logs;
+    if (eventType) {
+      sessions = sessions.filter((s2) => s2.eventType === eventType);
+    }
+    return sessions.map((s2) => ({
+      ...s2,
+      entries: []
+    }));
+  },
+  async getAllSessionsWithEntries() {
+    const logs = await this.getActivityLogs();
+    return logs.sessions;
+  },
+  async getSession(sessionId) {
+    const logs = await this.getActivityLogs();
+    const session = logs.sessions.find((s2) => s2.id === sessionId);
+    return session || null;
+  },
+  async clearSessions() {
+    await this.saveActivityLogs(emptyActivityLogs);
+  }
+});
 const services = {
   LocalazyUserService,
   StrapiService,
@@ -26403,7 +26857,8 @@ const services = {
   StrapiI18nService,
   LocalazyUploadService,
   StrapiLocalazyI18nService,
-  EntryExclusionService
+  EntryExclusionService,
+  ActivityLogsService
 };
 const index = {
   register,