@localazy/strapi-plugin 1.3.0 → 1.4.0

package/dist/server/index.mjs

@@ -1,5 +1,5 @@
 import require$$0$4 from "http";
-import require$$1$4 from "fs";
+import require$$1$4, { promises } from "fs";
 import require$$1$1 from "zlib";
 import require$$1 from "path";
 import require$$4 from "stream";
@@ -9,6 +9,7 @@ import require$$0$2 from "crypto";
 import require$$0$3 from "events";
 import require$$2 from "timers";
 import require$$8, { WebSocketServer } from "ws";
+import JSZip from "jszip";
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getDefaultExportFromCjs(x2) {
   return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
@@ -20519,7 +20520,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.3.0";
+const version = "1.4.0";
 const description = "The official Strapi Plugin by Localazy.";
 const keywords = [
   "strapi",
@@ -20589,6 +20590,7 @@ const scripts = {
   prepare: "husky || true"
 };
 const dependencies = {
+  jszip: "^3.10.1",
   shelljs: "^0.8.5",
   ws: "^8.18.0"
 };
@@ -24488,6 +24490,413 @@ const ActivityLogsController = ({ strapi: _strapi }) => ({
     ctx.body = { success: true };
   }
 });
+const URL_SECRET_KEYS = ["token", "secret", "signature", "key", "apikey", "api_key"];
+const DEBUG_BUNDLE_ENV_ALLOWLIST = [
+  "STRAPI_ADMIN_LOCALAZY_ENV",
+  "STRAPI_ADMIN_BACKEND_URL",
+  "NODE_ENV",
+  "STRAPI_TELEMETRY_DISABLED"
+];
+const redactIdentity = (identity2) => {
+  if (!identity2) return null;
+  return {
+    userId: identity2.user?.id ?? "",
+    name: identity2.user?.name ?? "",
+    scope: identity2.scope ?? "",
+    hasAccessToken: Boolean(identity2.accessToken)
+  };
+};
+const scrubUrlSecrets = (input) => {
+  if (typeof input !== "string") return input;
+  if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(input) && !input.includes("?")) return input;
+  try {
+    const url2 = new URL(input);
+    let mutated = false;
+    for (const k2 of [...url2.searchParams.keys()]) {
+      if (URL_SECRET_KEYS.includes(k2.toLowerCase())) {
+        url2.searchParams.delete(k2);
+        mutated = true;
+      }
+    }
+    return mutated ? url2.toString() : input;
+  } catch {
+    return input;
+  }
+};
+const pickEnvAllowlist = (env) => {
+  const out = {};
+  for (const key of DEBUG_BUNDLE_ENV_ALLOWLIST) {
+    const raw = env[key];
+    const present = raw !== void 0;
+    out[key] = {
+      present,
+      value: present ? raw : null
+    };
+  }
+  return out;
+};
+const serializeContentTypeSchema = (contentType) => {
+  if (!contentType || typeof contentType !== "object") return null;
+  const ct = contentType;
+  return {
+    kind: ct.kind,
+    collectionName: ct.collectionName,
+    info: ct.info,
+    options: ct.options,
+    pluginOptions: ct.pluginOptions,
+    attributes: ct.attributes
+  };
+};
+const DOCUMENT_INTERNAL_FIELDS = ["createdBy", "updatedBy"];
+const stripDocumentInternals = (doc) => {
+  if (!doc || typeof doc !== "object") return doc;
+  const clone = { ...doc };
+  for (const field of DOCUMENT_INTERNAL_FIELDS) {
+    delete clone[field];
+  }
+  return clone;
+};
+class SessionNotFoundError extends Error {
+  constructor(sessionId) {
+    super(`Session ${sessionId} not found`);
+    this.name = "SessionNotFoundError";
+  }
+}
+const DEBUG_BUNDLE_SCHEMA_VERSION = 1;
+const CAPS = {
+  perEntryBytes: 1 * 1024 * 1024,
+  // 1 MB
+  totalEntries: 100,
+  errorLogBytes: 2 * 1024 * 1024,
+  // 2 MB
+  consoleErrorsLines: 200,
+  browserPayloadBytes: 64 * 1024
+  // 64 KB
+};
+const selectAttemptedEntries = (attempted) => {
+  const failedByKey = /* @__PURE__ */ new Map();
+  const successByKey = /* @__PURE__ */ new Map();
+  for (const record of attempted) {
+    const key = `${record.uid}|${record.documentId}|${record.locale}`;
+    const selected = {
+      uid: record.uid,
+      documentId: record.documentId,
+      locale: record.locale,
+      status: record.status,
+      attemptedAt: record.attemptedAt
+    };
+    if (record.status === "failed") {
+      successByKey.delete(key);
+      if (!failedByKey.has(key)) failedByKey.set(key, selected);
+    } else if (!failedByKey.has(key) && !successByKey.has(key)) {
+      successByKey.set(key, selected);
+    }
+  }
+  return [...failedByKey.values(), ...successByKey.values()];
+};
+const formatTimestampForFilename = (ms2) => new Date(ms2).toISOString().replace(/[:.]/g, "-");
+const safeUidForPath = (uid) => uid.replace(/::/g, "--").replace(/\./g, "-");
+const decodeBrowserPayload = (encoded) => {
+  const markers = [];
+  if (!encoded) return { payload: null, truncationMarkers: markers };
+  try {
+    const raw = Buffer.from(encoded, "base64").toString("utf8");
+    const rawBytes = Buffer.byteLength(raw, "utf8");
+    if (rawBytes > CAPS.browserPayloadBytes) {
+      markers.push({ kind: "browser-payload-truncated", originalSizeBytes: rawBytes });
+      return { payload: null, truncationMarkers: markers };
+    }
+    const parsed = JSON.parse(raw);
+    if (parsed && Array.isArray(parsed.consoleErrors) && parsed.consoleErrors.length > CAPS.consoleErrorsLines) {
+      markers.push({ kind: "console-errors-truncated", originalCount: parsed.consoleErrors.length });
+      parsed.consoleErrors = parsed.consoleErrors.slice(0, CAPS.consoleErrorsLines);
+    }
+    return { payload: parsed, truncationMarkers: markers };
+  } catch {
+    return { payload: null, truncationMarkers: markers };
+  }
+};
+const deepScrubUrls = (value) => {
+  if (value == null) return value;
+  if (typeof value === "string") return scrubUrlSecrets(value);
+  if (Array.isArray(value)) return value.map(deepScrubUrls);
+  if (typeof value === "object") {
+    const out = {};
+    for (const [k2, v2] of Object.entries(value)) {
+      out[k2] = deepScrubUrls(v2);
+    }
+    return out;
+  }
+  return value;
+};
+const sanitizePluginSettings = (settings) => {
+  const cloned = JSON.parse(JSON.stringify(settings ?? {}));
+  if (cloned.webhookConfig?.url) {
+    cloned.webhookConfig.url = scrubUrlSecrets(cloned.webhookConfig.url);
+  }
+  return cloned;
+};
+const sanitizeSession = (session) => {
+  const cloned = JSON.parse(JSON.stringify(session));
+  for (const entry of cloned.entries ?? []) {
+    if (entry.data !== void 0) {
+      entry.data = deepScrubUrls(entry.data);
+    }
+  }
+  return cloned;
+};
+const buildErrorLog = (session) => {
+  const lines = [];
+  for (const entry of session.entries ?? []) {
+    const ts = Number.isFinite(entry.timestamp) ? new Date(entry.timestamp).toISOString() : "unknown";
+    lines.push(`${ts}  ${entry.message}`);
+  }
+  if (session.status === "failed" && session.summary) {
+    lines.push(`ERROR: ${session.summary}`);
+  }
+  const full = lines.join("\n");
+  const fullBytes = Buffer.byteLength(full, "utf8");
+  if (fullBytes <= CAPS.errorLogBytes) {
+    return { text: full, markers: [] };
+  }
+  const truncated = Buffer.from(full, "utf8").subarray(fullBytes - CAPS.errorLogBytes).toString("utf8");
+  return {
+    text: `...[truncated, kept last ${CAPS.errorLogBytes} bytes]
+${truncated}`,
+    markers: [{ kind: "error-log-truncated", originalSizeBytes: fullBytes }]
+  };
+};
+const readHostPackages = async (strapi2) => {
+  const appRoot = strapi2?.dirs?.app?.root ?? process.cwd();
+  if (!appRoot) return { data: null, reason: "host-app-root-unknown" };
+  try {
+    const raw = await promises.readFile(require$$1.join(appRoot, "package.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      data: {
+        name: parsed.name,
+        version: parsed.version,
+        dependencies: parsed.dependencies ?? {},
+        devDependencies: parsed.devDependencies ?? {}
+      }
+    };
+  } catch (err) {
+    return { data: null, reason: err instanceof Error ? err.message : String(err) };
+  }
+};
+const buildReadme = ({
+  sessionShortId,
+  sessionId,
+  schemaVersion,
+  hostPackagesSkipped
+}) => {
+  const lines = [];
+  lines.push(`# Localazy Strapi Plugin — Troubleshooting Bundle`);
+  lines.push("");
+  lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push(`Session id: ${sessionId}`);
+  lines.push(`Schema version: ${schemaVersion}`);
+  lines.push("");
+  lines.push("## Contents");
+  lines.push("");
+  lines.push("- `meta.json` — schema version, session metadata.");
+  lines.push("- `versions.json` — plugin version, Strapi version, Node version, platform/arch.");
+  lines.push("- `env.json` — allow-listed environment variables only.");
+  lines.push("- `browser.json` — user agent, language, viewport, console errors (from the admin UI).");
+  lines.push("- `session.json` — full activity-log session record (URLs scrubbed of secret query keys).");
+  lines.push("- `error.log` — chronological text log of session entries.");
+  lines.push("- `plugin-settings.json` — full plugin settings (webhook URL secrets scrubbed).");
+  lines.push("- `content-transfer-setup.json` — content-transfer setup record.");
+  if (hostPackagesSkipped) {
+    lines.push("- `host-packages.json` — NOT INCLUDED (could not be read; see `bundle-truncated.json`).");
+  } else {
+    lines.push("- `host-packages.json` — host project's package.json (deps + devDeps only).");
+  }
+  lines.push("- `content-types/` — schema.json per touched content-type UID.");
+  lines.push("- `entries/<uid>/<documentId>--<locale>.json` — per-entry payload from `strapi.documents().findOne()`.");
+  lines.push("- `bundle-truncated.json` — present only if any per-section cap was exceeded.");
+  lines.push("");
+  lines.push("## Reproducing locally");
+  lines.push("");
+  lines.push("1. `unzip` the bundle.");
+  lines.push("2. Recreate the content types from `content-types/*.schema.json` in your Strapi project.");
+  lines.push("3. Import the entries via the Document Service using `entries/<uid>/*.json`.");
+  lines.push("4. Apply `plugin-settings.json` and `content-transfer-setup.json` via the plugin admin UI.");
+  lines.push("5. Trigger the same upload/download/webhook with the same locale set.");
+  lines.push("6. Compare the failure against `error.log` and `session.json`.");
+  lines.push("");
+  lines.push(`Bundle short id: ${sessionShortId}`);
+  return lines.join("\n");
+};
+const buildDebugBundle = async ({
+  strapi: strapi2,
+  sessionId,
+  browserPayloadEncoded
+}) => {
+  const zip = new JSZip();
+  const truncationMarkers = [];
+  const pluginName = "localazy";
+  const activityLogsService = strapi2.plugin(pluginName).service("ActivityLogsService");
+  const pluginSettingsService = strapi2.plugin(pluginName).service("PluginSettingsService");
+  const strapiService = strapi2.plugin(pluginName).service("StrapiService");
+  const localazyUserService = strapi2.plugin(pluginName).service("LocalazyUserService");
+  const session = await activityLogsService.getSession(sessionId);
+  if (!session) {
+    throw new SessionNotFoundError(sessionId);
+  }
+  const sessionShortId = session.id.slice(0, 8);
+  const pluginSettingsRaw = await pluginSettingsService.getPluginSettings();
+  const contentTransferSetup = await pluginSettingsService.getContentTransferSetup();
+  const identity2 = await localazyUserService.getUser();
+  const redactedIdentity = redactIdentity(identity2);
+  const pluginVersion = await strapiService.getPluginVersion();
+  const strapiVersion = strapiService.getStrapiVersion();
+  zip.file(
+    "meta.json",
+    JSON.stringify(
+      {
+        schemaVersion: DEBUG_BUNDLE_SCHEMA_VERSION,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId: session.id,
+        sessionShortId,
+        eventType: session.eventType,
+        status: session.status,
+        startedAt: session.startedAt,
+        finishedAt: session.finishedAt ?? null,
+        initiatedBy: session.initiatedBy,
+        identity: redactedIdentity
+      },
+      null,
+      2
+    )
+  );
+  zip.file(
+    "versions.json",
+    JSON.stringify(
+      {
+        plugin: { name: "@localazy/strapi-plugin", version: pluginVersion },
+        strapi: { version: strapiVersion },
+        node: process.version,
+        platform: process.platform,
+        arch: process.arch
+      },
+      null,
+      2
+    )
+  );
+  const envSnapshot = pickEnvAllowlist(process.env);
+  zip.file(
+    "env.json",
+    JSON.stringify(
+      {
+        allowlist: [...DEBUG_BUNDLE_ENV_ALLOWLIST],
+        values: envSnapshot
+      },
+      null,
+      2
+    )
+  );
+  const { payload: browserPayload, truncationMarkers: browserMarkers } = decodeBrowserPayload(browserPayloadEncoded);
+  truncationMarkers.push(...browserMarkers);
+  zip.file("browser.json", JSON.stringify(browserPayload ? browserPayload : { captured: false }, null, 2));
+  zip.file("session.json", JSON.stringify(sanitizeSession(session), null, 2));
+  const { text: errorLogText, markers: errorLogMarkers } = buildErrorLog(session);
+  truncationMarkers.push(...errorLogMarkers);
+  zip.file("error.log", errorLogText);
+  zip.file("plugin-settings.json", JSON.stringify(sanitizePluginSettings(pluginSettingsRaw), null, 2));
+  zip.file("content-transfer-setup.json", JSON.stringify(contentTransferSetup, null, 2));
+  const hostPackages = await readHostPackages(strapi2);
+  if (hostPackages.data) {
+    zip.file("host-packages.json", JSON.stringify(hostPackages.data, null, 2));
+  }
+  if (session.attemptedEntries === void 0) {
+    truncationMarkers.push({ kind: "attempted-entries-missing-legacy-session" });
+  }
+  const selected = selectAttemptedEntries(session.attemptedEntries ?? []);
+  const kept = selected.slice(0, CAPS.totalEntries);
+  const skipped = selected.slice(CAPS.totalEntries);
+  if (skipped.length > 0) {
+    truncationMarkers.push({
+      kind: "entries-skipped",
+      tuples: skipped.map(({ uid, documentId, locale }) => ({ uid, documentId, locale }))
+    });
+  }
+  const uniqueUids = [...new Set(kept.map((t3) => t3.uid))];
+  for (const uid of uniqueUids) {
+    const schema = serializeContentTypeSchema(strapi2.contentTypes?.[uid]);
+    if (schema) {
+      zip.file(`content-types/${safeUidForPath(uid)}.schema.json`, JSON.stringify(schema, null, 2));
+    }
+  }
+  for (const tuple of kept) {
+    let documentJson = null;
+    try {
+      const doc = await strapi2.documents(tuple.uid).findOne({ documentId: tuple.documentId, locale: tuple.locale, populate: "*" });
+      documentJson = doc ? stripDocumentInternals(doc) : { __not_found: true, attemptedAt: tuple.attemptedAt };
+    } catch (err) {
+      documentJson = { __error: err instanceof Error ? err.message : String(err) };
+    }
+    const serialised = JSON.stringify(documentJson, null, 2);
+    const sizeBytes = Buffer.byteLength(serialised, "utf8");
+    let body;
+    if (sizeBytes > CAPS.perEntryBytes) {
+      truncationMarkers.push({
+        kind: "entry-too-large",
+        uid: tuple.uid,
+        documentId: tuple.documentId,
+        locale: tuple.locale,
+        originalSizeBytes: sizeBytes
+      });
+      body = JSON.stringify({ __truncated: true, originalSizeBytes: sizeBytes }, null, 2);
+    } else {
+      body = serialised;
+    }
+    const safeDocId = tuple.documentId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    zip.file(`entries/${safeUidForPath(tuple.uid)}/${safeDocId}--${tuple.locale}.json`, body);
+  }
+  zip.file(
+    "README.md",
+    buildReadme({
+      sessionShortId,
+      sessionId: session.id,
+      schemaVersion: DEBUG_BUNDLE_SCHEMA_VERSION,
+      hostPackagesSkipped: !hostPackages.data
+    })
+  );
+  if (truncationMarkers.length > 0 || !hostPackages.data) {
+    const marker = {
+      schemaVersion: DEBUG_BUNDLE_SCHEMA_VERSION,
+      markers: truncationMarkers,
+      hostPackagesSkipped: hostPackages.data ? null : hostPackages.reason ?? "unknown"
+    };
+    zip.file("bundle-truncated.json", JSON.stringify(marker, null, 2));
+  }
+  const zipBuffer = await zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE" });
+  const filename = `localazy-debug-bundle-${sessionShortId}-${formatTimestampForFilename(Date.now())}.zip`;
+  return { zipBuffer, filename };
+};
+const DebugBundleController = ({ strapi: strapi2 }) => ({
+  async getBundle(ctx) {
+    const { sessionId } = ctx.params;
+    const browserPayloadEncoded = typeof ctx.query.browser === "string" ? ctx.query.browser : null;
+    try {
+      const { zipBuffer, filename } = await buildDebugBundle({
+        strapi: strapi2,
+        sessionId,
+        browserPayloadEncoded
+      });
+      ctx.type = "application/zip";
+      ctx.set("Content-Disposition", `attachment; filename="${filename}"`);
+      ctx.body = zipBuffer;
+    } catch (err) {
+      if (err instanceof SessionNotFoundError) {
+        return ctx.notFound("Session not found");
+      }
+      strapi2.log.error(`[localazy] failed to build debug bundle: ${err instanceof Error ? err.message : err}`);
+      throw err;
+    }
+  }
+});
 const controllers = {
   LocalazyUserController,
   LocalazyAuthController,
@@ -24496,7 +24905,8 @@ const controllers = {
   PluginSettingsController,
   LocalazyTransferController,
   EntryExclusionController,
-  ActivityLogsController
+  ActivityLogsController,
+  DebugBundleController
 };
 const verifyWebhook = (config2, { strapi: strapi2 }) => {
   return async (ctx, next) => {
@@ -24807,6 +25217,16 @@ const ActivityLogsRoutes = [
     }
   }
 ];
+const DebugBundleRoutes = [
+  {
+    method: "GET",
+    path: "/activity-logs/:sessionId/bundle",
+    handler: "DebugBundleController.getBundle",
+    config: {
+      policies: []
+    }
+  }
+];
 const routes = {
   "content-api": {
     routes: [...StrapiRoutes]
@@ -24821,7 +25241,8 @@ const routes = {
       ...LocalazyTransferRoutes,
       ...LocalazyProjectRoutes,
       ...EntryExclusionRoutes,
-      ...ActivityLogsRoutes
+      ...ActivityLogsRoutes,
+      ...DebugBundleRoutes
     ]
   },
   LocalazyPublicTransferRoutes: {
@@ -25100,6 +25521,8 @@ const LocalazyTransferUploadService = ({ strapi: strapi2 }) => ({
     const { setup: setup2 } = contentTransferSetup;
     const collectionsNames = getCollectionsNames(setup2);
     const models = await StrapiService2.getModels();
+    const strapiDefaultLocaleCode = await StrapiI18nService2.getDefaultLocaleCode();
+    const attemptedTuples = [];
     let pickedFlattenStrapiContent = {};
     for (const collectionName of collectionsNames) {
       const currentModel = models.find((model) => model.collectionName === collectionName);
@@ -25162,6 +25585,15 @@ const LocalazyTransferUploadService = ({ strapi: strapi2 }) => ({
       });
       await activityLogsService.addEntry(sessionId, message);
       strapi2.log.info(message);
+      if (strapiDefaultLocaleCode) {
+        for (const entry of entries) {
+          attemptedTuples.push({
+            uid: modelUid,
+            documentId: entry.documentId,
+            locale: strapiDefaultLocaleCode
+          });
+        }
+      }
       entries = omitDeep(entries, ["locale", "createdAt", "updatedAt", "publishedAt"]);
       entries.forEach((entry) => {
         const flatten = flattenObject({
@@ -25179,7 +25611,6 @@ const LocalazyTransferUploadService = ({ strapi: strapi2 }) => ({
         ...characterLimitsMetadata
       };
     }
-    const strapiDefaultLocaleCode = await StrapiI18nService2.getDefaultLocaleCode();
     const localazyLocaleCode = strapiDefaultLocaleCode ? isoStrapiToLocalazy(strapiDefaultLocaleCode) : config.default.LOCALAZY_DEFAULT_LOCALE;
     const importFile = LocalazyUploadService2.createImportFileRepresentation(
       localazyLocaleCode,
@@ -25201,6 +25632,10 @@ const LocalazyTransferUploadService = ({ strapi: strapi2 }) => ({
     await activityLogsService.addEntry(sessionId, "Uploading collections to Localazy...");
     try {
       await LocalazyUploadService2.upload(importFile, uploadConfig);
+      await activityLogsService.recordAttemptedEntries(
+        sessionId,
+        attemptedTuples.map((t3) => ({ ...t3, status: "success" }))
+      );
     } catch (error) {
       success = false;
       const errorMessage = `Upload to Localazy failed: ${error instanceof Error ? error.message : String(error)}`;
@@ -25210,6 +25645,10 @@ const LocalazyTransferUploadService = ({ strapi: strapi2 }) => ({
         message: errorMessage
       });
       await activityLogsService.addEntry(sessionId, errorMessage);
+      await activityLogsService.recordAttemptedEntries(
+        sessionId,
+        attemptedTuples.map((t3) => ({ ...t3, status: "failed", errorMessage }))
+      );
       await activityLogsService.finishSession(sessionId, "failed", errorMessage);
       console.timeEnd("upload");
       return;
@@ -25934,6 +26373,12 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
                   message
                 });
                 await activityLogsService.addEntry(sessionId, message);
+                await activityLogsService.recordAttemptedEntry(sessionId, {
+                  uid,
+                  documentId,
+                  locale: isoStrapi,
+                  status: "success"
+                });
                 await markKeysProcessed(sourceKeys);
               } catch (e2) {
                 success = false;
@@ -25950,6 +26395,13 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
                   sessionId,
                   `Failed to create ${uid} [${documentId}] in ${isoStrapi}: ${e2.message}`
                 );
+                await activityLogsService.recordAttemptedEntry(sessionId, {
+                  uid,
+                  documentId,
+                  locale: isoStrapi,
+                  status: "failed",
+                  errorMessage: e2.message
+                });
               }
             } else {
               try {
@@ -25968,6 +26420,12 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
                   message
                 });
                 await activityLogsService.addEntry(sessionId, message);
+                await activityLogsService.recordAttemptedEntry(sessionId, {
+                  uid,
+                  documentId,
+                  locale: isoStrapi,
+                  status: "success"
+                });
                 await markKeysProcessed(sourceKeys);
               } catch (e2) {
                 success = false;
@@ -25984,6 +26442,13 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
                   sessionId,
                   `Failed to update ${uid} [${documentId}] in ${isoStrapi}: ${e2.message}`
                 );
+                await activityLogsService.recordAttemptedEntry(sessionId, {
+                  uid,
+                  documentId,
+                  locale: isoStrapi,
+                  status: "failed",
+                  errorMessage: e2.message
+                });
               }
             }
           } catch (e2) {
@@ -25996,6 +26461,13 @@ const LocalazyTransferDownloadService = ({ strapi: strapi2 }) => ({
               sessionId,
               `Error processing ${uid} [${documentId}] in ${isoStrapi}: ${e2.message}`
             );
+            await activityLogsService.recordAttemptedEntry(sessionId, {
+              uid,
+              documentId,
+              locale: isoStrapi,
+              status: "failed",
+              errorMessage: e2.message
+            });
           }
         }
       }
@@ -26746,6 +27218,7 @@ const emptyActivityLogs = {
   sessions: []
 };
 const ONE_YEAR_MS = 365 * 24 * 60 * 60 * 1e3;
+const ATTEMPTED_ENTRIES_CAP = 5e3;
 let writeLock = Promise.resolve();
 const withLock = async (fn) => {
   let release;
@@ -26810,6 +27283,38 @@ const ActivityLogsService = ({ strapi: strapi2 }) => ({
       await this.saveActivityLogs(logs);
     });
   },
+  async recordAttemptedEntry(sessionId, entry) {
+    return this.recordAttemptedEntries(sessionId, [entry]);
+  },
+  async recordAttemptedEntries(sessionId, entries) {
+    if (!entries.length) {
+      return;
+    }
+    return withLock(async () => {
+      const logs = await this.getActivityLogs();
+      const session = logs.sessions.find((s2) => s2.id === sessionId);
+      if (!session) {
+        return;
+      }
+      if (!session.attemptedEntries) {
+        session.attemptedEntries = [];
+      }
+      const now = Date.now();
+      const wasAtCap = session.attemptedEntries.length >= ATTEMPTED_ENTRIES_CAP;
+      const remaining = Math.max(0, ATTEMPTED_ENTRIES_CAP - session.attemptedEntries.length);
+      const accepted = entries.slice(0, remaining);
+      const dropped = entries.length - accepted.length;
+      for (const entry of accepted) {
+        session.attemptedEntries.push({ ...entry, attemptedAt: now });
+      }
+      if (dropped > 0 && !wasAtCap) {
+        strapi2.log.warn(
+          `[localazy] attemptedEntries cap (${ATTEMPTED_ENTRIES_CAP}) reached for session ${sessionId}; ${dropped} record(s) dropped.`
+        );
+      }
+      await this.saveActivityLogs(logs);
+    });
+  },
   async finishSession(sessionId, status, summary) {
     return withLock(async () => {
       const logs = await this.getActivityLogs();

package/dist/server/src/controllers/debug-bundle-controller.d.ts

@@ -0,0 +1,7 @@
+import type { Core } from '@strapi/strapi';
+declare const DebugBundleController: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    getBundle(ctx: any): Promise<any>;
+};
+export default DebugBundleController;

package/dist/server/src/controllers/index.d.ts

@@ -58,5 +58,10 @@ declare const _default: {
         exportSessions(ctx: any): Promise<void>;
         clearSessions(ctx: any): Promise<void>;
     };
+    DebugBundleController: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        getBundle(ctx: any): Promise<any>;
+    };
 };
 export default _default;

package/dist/server/src/core/index.d.ts

@@ -86,6 +86,8 @@ export declare const getActivityLogsService: () => {
     saveActivityLogs(logs: import("../db/model/activity-logs").ActivityLogs): Promise<void>;
     startSession(eventType: "upload" | "download" | "webhook", initiatedBy: string): Promise<string>;
     addEntry(sessionId: string, message: string, data?: any): Promise<void>;
+    recordAttemptedEntry(sessionId: string, entry: Omit<import("../db/model/activity-logs").AttemptedEntry, "attemptedAt">): Promise<void>;
+    recordAttemptedEntries(sessionId: string, entries: Omit<import("../db/model/activity-logs").AttemptedEntry, "attemptedAt">[]): Promise<void>;
     finishSession(sessionId: string, status: "completed" | "failed", summary: string): Promise<void>;
     getSessions(eventType?: "upload" | "download" | "webhook"): Promise<import("../db/model/activity-logs").ActivityLogSession[]>;
     getAllSessionsWithEntries(): Promise<import("../db/model/activity-logs").ActivityLogSession[]>;