@yishiguji/tokenarena 0.8.7 → 0.8.8

package/dist/index.js

@@ -4836,14 +4836,19 @@ import { URL as URL2 } from "url";
 var MAX_RETRIES = 3;
 var INITIAL_DELAY = 1e3;
 var TIMEOUT_MS = 6e4;
-function getIngestPayloadSize(device, buckets, sessions) {
-  const payload = {
+function buildIngestPayload(device, buckets, sessions, options) {
+  return {
     schemaVersion: 2,
     device,
     buckets,
-    sessions: sessions ?? []
+    sessions: sessions ?? [],
+    ...options?.syncAchievements === void 0 ? {} : { syncAchievements: options.syncAchievements }
   };
-  return Buffer.byteLength(JSON.stringify(payload));
+}
+function getIngestPayloadSize(device, buckets, sessions, options) {
+  return Buffer.byteLength(
+    JSON.stringify(buildIngestPayload(device, buckets, sessions, options))
+  );
 }
 var ApiClient = class {
   constructor(apiUrl, apiKey) {
@@ -4855,11 +4860,17 @@ var ApiClient = class {
   /**
    * Ingest buckets and sessions to server
    */
-  async ingest(device, buckets, sessions, onProgress) {
+  async ingest(device, buckets, sessions, onProgress, options) {
     let lastError;
     for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
       try {
-        return await this.sendIngest(device, buckets, sessions, onProgress);
+        return await this.sendIngest(
+          device,
+          buckets,
+          sessions,
+          onProgress,
+          options
+        );
       } catch (err) {
         lastError = err;
         const httpErr = err;
@@ -4874,16 +4885,11 @@ var ApiClient = class {
     }
     throw lastError;
   }
-  sendIngest(device, buckets, sessions, onProgress) {
+  sendIngest(device, buckets, sessions, onProgress, options) {
     return new Promise((resolve4, reject) => {
       const url = new URL2("/api/usage/ingest", this.apiUrl);
       const body = Buffer.from(
-        JSON.stringify({
-          schemaVersion: 2,
-          device,
-          buckets,
-          sessions: sessions ?? []
-        })
+        JSON.stringify(buildIngestPayload(device, buckets, sessions, options))
       );
       const totalBytes = body.length;
       const mod = url.protocol === "https:" ? https : http;
@@ -5316,6 +5322,7 @@ function getDetectedTools() {
 // src/services/sync-service.ts
 var BATCH_SIZE = 100;
 var SESSION_BATCH_SIZE = 500;
+var MAX_INGEST_PAYLOAD_BYTES = 8 * 1024 * 1024;
 var PROGRESS_BAR_WIDTH = 28;
 function formatBytes(bytes) {
   if (bytes < 1024) return `${bytes}B`;
@@ -5327,6 +5334,9 @@ function renderProgressBar(progress) {
   const filled = Math.round(safeProgress * PROGRESS_BAR_WIDTH);
   return `${"\u2588".repeat(filled)}${"\u2591".repeat(PROGRESS_BAR_WIDTH - filled)}`;
 }
+function shouldSyncAchievementsForBatch(batchIndex, totalBatches) {
+  return batchIndex === totalBatches - 1;
+}
 function writeUploadProgress(sent, total, batchNum, totalBatches) {
   const pct = total > 0 ? Math.round(sent / total * 100) : 100;
   const progressBar = renderProgressBar(total > 0 ? sent / total : 1);
@@ -5456,6 +5466,64 @@ var SyncFailure = class extends Error {
   kind;
   causeError;
 };
+function splitOversizedUploadBatch(device, buckets, sessions) {
+  const payloadSize = getIngestPayloadSize(device, buckets, sessions, {
+    syncAchievements: true
+  });
+  if (payloadSize <= MAX_INGEST_PAYLOAD_BYTES) {
+    return [{ buckets, sessions }];
+  }
+  if (buckets.length + sessions.length <= 1) {
+    throw new SyncFailure(
+      `A single usage record exceeds the ${formatBytes(MAX_INGEST_PAYLOAD_BYTES)} ingest payload limit. Reduce the record size before syncing.`,
+      "error"
+    );
+  }
+  if (sessions.length > 1 && sessions.length >= buckets.length) {
+    const midpoint = Math.ceil(sessions.length / 2);
+    return [
+      ...splitOversizedUploadBatch(
+        device,
+        buckets,
+        sessions.slice(0, midpoint)
+      ),
+      ...splitOversizedUploadBatch(device, [], sessions.slice(midpoint))
+    ];
+  }
+  if (buckets.length > 1) {
+    const midpoint = Math.ceil(buckets.length / 2);
+    return [
+      ...splitOversizedUploadBatch(
+        device,
+        buckets.slice(0, midpoint),
+        sessions
+      ),
+      ...splitOversizedUploadBatch(device, buckets.slice(midpoint), [])
+    ];
+  }
+  return [
+    ...splitOversizedUploadBatch(device, buckets, []),
+    ...splitOversizedUploadBatch(device, [], sessions)
+  ];
+}
+function buildUploadBatches(device, buckets, sessions) {
+  const batches = [];
+  let bucketOffset = 0;
+  let sessionOffset = 0;
+  while (bucketOffset < buckets.length || sessionOffset < sessions.length) {
+    const batchBuckets = buckets.slice(bucketOffset, bucketOffset + BATCH_SIZE);
+    const batchSessions = sessions.slice(
+      sessionOffset,
+      sessionOffset + SESSION_BATCH_SIZE
+    );
+    batches.push(
+      ...splitOversizedUploadBatch(device, batchBuckets, batchSessions)
+    );
+    bucketOffset += batchBuckets.length;
+    sessionOffset += batchSessions.length;
+  }
+  return batches;
+}
 async function runSync(config, opts = {}) {
   const { quiet = false, source = "manual", throws = false } = opts;
   const lock = tryAcquireSyncLock(source);
@@ -5596,24 +5664,19 @@ async function runSync(config, opts = {}) {
       markSyncSucceeded(source, { buckets: 0, sessions: 0 });
       return { buckets: 0, sessions: 0 };
     }
-    const bucketBatches = Math.ceil(changedBuckets.length / BATCH_SIZE);
-    const sessionBatches = Math.ceil(
-      changedSessions.length / SESSION_BATCH_SIZE
+    const uploadBatches = buildUploadBatches(
+      device,
+      changedBuckets,
+      changedSessions
     );
-    const totalBatches = Math.max(bucketBatches, sessionBatches, 1);
-    const batchPayloadSizes = Array.from(
-      { length: totalBatches },
-      (_, batchIdx) => getIngestPayloadSize(
-        device,
-        changedBuckets.slice(
-          batchIdx * BATCH_SIZE,
-          (batchIdx + 1) * BATCH_SIZE
-        ),
-        changedSessions.slice(
-          batchIdx * SESSION_BATCH_SIZE,
-          (batchIdx + 1) * SESSION_BATCH_SIZE
+    const totalBatches = uploadBatches.length;
+    const batchPayloadSizes = uploadBatches.map(
+      (batch, batchIdx) => getIngestPayloadSize(device, batch.buckets, batch.sessions, {
+        syncAchievements: shouldSyncAchievementsForBatch(
+          batchIdx,
+          totalBatches
         )
-      )
+      })
     );
     const totalPayloadBytes = batchPayloadSizes.reduce(
       (sum, size) => sum + size,
@@ -5640,14 +5703,11 @@ async function runSync(config, opts = {}) {
       );
     }
     for (let batchIdx = 0; batchIdx < totalBatches; batchIdx++) {
-      const batch = changedBuckets.slice(
-        batchIdx * BATCH_SIZE,
-        (batchIdx + 1) * BATCH_SIZE
-      );
-      const batchSessions = changedSessions.slice(
-        batchIdx * SESSION_BATCH_SIZE,
-        (batchIdx + 1) * SESSION_BATCH_SIZE
-      );
+      const uploadBatch = uploadBatches[batchIdx];
+      if (!uploadBatch) {
+        throw new SyncFailure("Upload batch planning failed.", "error");
+      }
+      const { buckets: batch, sessions: batchSessions } = uploadBatch;
       const batchNum = batchIdx + 1;
       const result = await apiClient.ingest(
         device,
@@ -5660,6 +5720,12 @@ async function runSync(config, opts = {}) {
             batchNum,
             totalBatches
           );
+        },
+        {
+          syncAchievements: shouldSyncAchievementsForBatch(
+            batchIdx,
+            totalBatches
+          )
         }
       );
       totalIngested += result.ingested ?? batch.length;