pushwork 1.0.22 → 1.0.26

package/src/utils/network-sync.ts

@@ -61,12 +61,13 @@ export async function waitForBidirectionalSync(
       ? getHandleHeads(handles)
       : await getAllDocumentHeads(repo, rootDirectoryUrl);
 
-    // Scale timeout proportionally to tree size after first scan
+    // After first scan: scale timeout to tree size and reset the clock.
+    // The first scan is just establishing a baseline — its duration
+    // shouldn't count against the stability-wait timeout.
     if (pollCount === 1) {
-      dynamicTimeoutMs = Math.max(timeoutMs, 5000 + currentHeads.size * 50);
-      if (dynamicTimeoutMs !== timeoutMs) {
-        debug(`waitForBidirectionalSync: scaled timeout to ${dynamicTimeoutMs}ms for ${currentHeads.size} docs`);
-      }
+      const scanDuration = Date.now() - startTime;
+      dynamicTimeoutMs = Math.max(timeoutMs, 5000 + currentHeads.size * 50) + scanDuration;
+      debug(`waitForBidirectionalSync: first scan took ${scanDuration}ms, timeout now ${dynamicTimeoutMs}ms for ${currentHeads.size} docs`);
     }
 
     // Check if heads are stable (no changes since last check)
@@ -206,126 +207,166 @@ function headsMapEqual(
 }
 
 /**
- * Wait for documents to sync to the remote server
+ * Result of waitForSync — lists which handles failed to sync.
+ */
+export interface SyncWaitResult {
+  failed: DocHandle<unknown>[];
+}
+
+/** Maximum documents to sync concurrently to avoid flooding the server */
+const SYNC_BATCH_SIZE = 10;
+
+/**
+ * Wait for a single document handle to sync to the server.
+ * Resolves with the handle on success, rejects with the handle on timeout.
+ */
+function waitForHandleSync(
+  handle: DocHandle<unknown>,
+  syncServerStorageId: StorageId,
+  timeoutMs: number,
+  startTime: number,
+): Promise<DocHandle<unknown>> {
+  return new Promise<DocHandle<unknown>>((resolve, reject) => {
+    let pollInterval: NodeJS.Timeout;
+
+    const cleanup = () => {
+      clearTimeout(timeout);
+      clearInterval(pollInterval);
+      handle.off("remote-heads", onRemoteHeads);
+    };
+
+    const onConverged = () => {
+      debug(`waitForSync: ${handle.url.slice(0, 20)}... converged in ${Date.now() - startTime}ms`);
+      cleanup();
+      resolve(handle);
+    };
+
+    const timeout = setTimeout(() => {
+      debug(`waitForSync: ${handle.url.slice(0, 20)}... timed out after ${timeoutMs}ms`);
+      cleanup();
+      reject(handle);
+    }, timeoutMs);
+
+    const isConverged = () => {
+      const localHeads = handle.heads();
+      const info = handle.getSyncInfo(syncServerStorageId);
+      return A.equals(localHeads, info?.lastHeads);
+    };
+
+    const onRemoteHeads = ({
+      storageId,
+    }: {
+      storageId: StorageId;
+      heads: any;
+    }) => {
+      if (storageId === syncServerStorageId && isConverged()) {
+        onConverged();
+      }
+    };
+
+    // Initial check
+    if (isConverged()) {
+      cleanup();
+      resolve(handle);
+      return;
+    }
+
+    // Start polling and event listening
+    pollInterval = setInterval(() => {
+      if (isConverged()) {
+        onConverged();
+      }
+    }, 100);
+
+    handle.on("remote-heads", onRemoteHeads);
+  });
+}
+
+/**
+ * Wait for documents to sync to the remote server.
+ * Processes handles in batches to avoid flooding the server.
+ * Returns a result with any failed handles instead of throwing,
+ * so callers can attempt recovery (e.g. recreating documents).
  */
 export async function waitForSync(
   handlesToWaitOn: DocHandle<unknown>[],
   syncServerStorageId?: StorageId,
   timeoutMs: number = 60000,
-): Promise<void> {
+): Promise<SyncWaitResult> {
   const startTime = Date.now();
 
   if (!syncServerStorageId) {
     debug("waitForSync: no sync server storage ID, skipping");
-    return;
+    return { failed: [] };
   }
 
   if (handlesToWaitOn.length === 0) {
     debug("waitForSync: no documents to sync");
-    return;
+    return { failed: [] };
   }
 
-  debug(`waitForSync: waiting for ${handlesToWaitOn.length} documents (timeout=${timeoutMs}ms)`);
+  debug(`waitForSync: waiting for ${handlesToWaitOn.length} documents (timeout=${timeoutMs}ms, batchSize=${SYNC_BATCH_SIZE})`);
 
+  // Separate already-synced from needs-sync
+  const needsSync: DocHandle<unknown>[] = [];
   let alreadySynced = 0;
 
-  const promises = handlesToWaitOn.map((handle) => {
-    // Check if already synced
+  for (const handle of handlesToWaitOn) {
     const heads = handle.heads();
     const syncInfo = handle.getSyncInfo(syncServerStorageId);
     const remoteHeads = syncInfo?.lastHeads;
-    const wasAlreadySynced = A.equals(heads, remoteHeads);
-
-    if (wasAlreadySynced) {
+    if (A.equals(heads, remoteHeads)) {
       alreadySynced++;
       debug(`waitForSync: ${handle.url.slice(0, 20)}... already synced`);
-      return Promise.resolve();
+    } else {
+      debug(`waitForSync: ${handle.url.slice(0, 20)}... needs sync (remoteHeads=${remoteHeads ? 'present' : 'missing'})`);
+      needsSync.push(handle);
     }
+  }
 
-    debug(`waitForSync: ${handle.url.slice(0, 20)}... waiting for convergence (remoteHeads=${remoteHeads ? 'present' : 'missing'})`);
-
-    // Wait for convergence
-    return new Promise<void>((resolve, reject) => {
-      let pollInterval: NodeJS.Timeout;
-
-      const cleanup = () => {
-        clearTimeout(timeout);
-        clearInterval(pollInterval);
-        handle.off("remote-heads", onRemoteHeads);
-      };
-
-      const onConverged = () => {
-        debug(`waitForSync: ${handle.url.slice(0, 20)}... converged in ${Date.now() - startTime}ms`);
-        cleanup();
-        resolve();
-      };
-
-      const timeout = setTimeout(() => {
-        debug(`waitForSync: ${handle.url.slice(0, 20)}... timed out after ${timeoutMs}ms`);
-        cleanup();
-        reject(
-          new Error(
-            `Sync timeout after ${timeoutMs}ms for document ${handle.url}`,
-          ),
-        );
-      }, timeoutMs);
-
-      const isConverged = () => {
-        const localHeads = handle.heads();
-        const info = handle.getSyncInfo(syncServerStorageId);
-        return A.equals(localHeads, info?.lastHeads);
-      };
-
-      const onRemoteHeads = ({
-        storageId,
-      }: {
-        storageId: StorageId;
-        heads: any;
-      }) => {
-        if (storageId === syncServerStorageId && isConverged()) {
-          onConverged();
-        }
-      };
+  if (needsSync.length > 0) {
+    debug(`waitForSync: ${alreadySynced} already synced, ${needsSync.length} need sync`);
+    out.taskLine(`Uploading: ${alreadySynced}/${handlesToWaitOn.length} already synced, waiting for ${needsSync.length} more`);
+  } else {
+    debug(`waitForSync: all ${handlesToWaitOn.length} already synced`);
+    return { failed: [] };
+  }
 
-      const poll = () => {
-        if (isConverged()) {
-          onConverged();
-          return true;
-        }
-        return false;
-      };
+  // Process in batches to avoid flooding the server
+  const failed: DocHandle<unknown>[] = [];
+  let synced = alreadySynced;
 
-      // Initial check
-      if (poll()) {
-        return;
-      }
+  for (let i = 0; i < needsSync.length; i += SYNC_BATCH_SIZE) {
+    const batch = needsSync.slice(i, i + SYNC_BATCH_SIZE);
+    const batchNum = Math.floor(i / SYNC_BATCH_SIZE) + 1;
+    const totalBatches = Math.ceil(needsSync.length / SYNC_BATCH_SIZE);
 
-      // Start polling and event listening
-      pollInterval = setInterval(() => {
-        poll();
-      }, 100);
+    if (totalBatches > 1) {
+      debug(`waitForSync: batch ${batchNum}/${totalBatches} (${batch.length} docs)`);
+      out.update(`Uploading batch ${batchNum}/${totalBatches} (${synced}/${handlesToWaitOn.length} done)`);
+    }
 
-      handle.on("remote-heads", onRemoteHeads);
-    });
-  });
+    const results = await Promise.allSettled(
+      batch.map(handle => waitForHandleSync(handle, syncServerStorageId, timeoutMs, startTime))
+    );
 
-  const needSync = handlesToWaitOn.length - alreadySynced;
-  if (needSync > 0) {
-    debug(`waitForSync: ${alreadySynced} already synced, waiting for ${needSync} remaining`);
-    out.taskLine(`Uploading: ${alreadySynced}/${handlesToWaitOn.length} already synced, waiting for ${needSync} more`);
-  } else {
-    debug(`waitForSync: all ${handlesToWaitOn.length} already synced`);
+    for (const result of results) {
+      if (result.status === "rejected") {
+        failed.push(result.reason as DocHandle<unknown>);
+      } else {
+        synced++;
+      }
+    }
   }
 
-  try {
-    await Promise.all(promises);
-    const elapsed = Date.now() - startTime;
+  const elapsed = Date.now() - startTime;
+  if (failed.length > 0) {
+    debug(`waitForSync: ${failed.length} documents failed after ${elapsed}ms`);
+    out.taskLine(`Upload: ${synced} synced, ${failed.length} failed after ${(elapsed / 1000).toFixed(1)}s`, true);
+  } else {
     debug(`waitForSync: all ${handlesToWaitOn.length} documents synced in ${elapsed}ms (${alreadySynced} were already synced)`);
     out.taskLine(`All ${handlesToWaitOn.length} documents uploaded to server (${(elapsed / 1000).toFixed(1)}s)`);
-  } catch (error) {
-    const elapsed = Date.now() - startTime;
-    debug(`waitForSync: failed after ${elapsed}ms: ${error}`);
-    out.taskLine(`Upload to server failed after ${(elapsed / 1000).toFixed(1)}s: ${error}`, true);
-    throw error;
   }
+
+  return { failed };
 }

package/src/utils/repo-factory.ts

@@ -22,7 +22,6 @@ export async function createRepo(
       config.sync_server
     );
     repoConfig.network = [networkAdapter];
-    repoConfig.enableRemoteHeadsGossiping = true;
   }
 
   const repo = new Repo(repoConfig);