pushwork 1.0.21 → 1.0.25

package/src/utils/network-sync.ts

@@ -32,12 +32,14 @@ export async function waitForBidirectionalSync(
     timeoutMs?: number;
     pollIntervalMs?: number;
     stableChecksRequired?: number;
+    handles?: DocHandle<unknown>[];
   } = {},
 ): Promise<void> {
   const {
     timeoutMs = 10000,
     pollIntervalMs = 100,
     stableChecksRequired = 3,
+    handles,
   } = options;
 
   if (!syncServerStorageId || !rootDirectoryUrl) {
@@ -48,13 +50,25 @@ export async function waitForBidirectionalSync(
   let lastSeenHeads = new Map<string, string>();
   let stableCount = 0;
   let pollCount = 0;
+  let dynamicTimeoutMs = timeoutMs;
 
-  debug(`waitForBidirectionalSync: starting (timeout=${timeoutMs}ms, stableChecks=${stableChecksRequired})`);
+  debug(`waitForBidirectionalSync: starting (timeout=${timeoutMs}ms, stableChecks=${stableChecksRequired}${handles ? `, tracking ${handles.length} handles` : ', full tree scan'})`);
 
-  while (Date.now() - startTime < timeoutMs) {
+  while (Date.now() - startTime < dynamicTimeoutMs) {
     pollCount++;
-    // Get current heads for all documents in the directory hierarchy
-    const currentHeads = await getAllDocumentHeads(repo, rootDirectoryUrl);
+    // Get current heads: use provided handles if available, otherwise full tree scan
+    const currentHeads = handles
+      ? getHandleHeads(handles)
+      : await getAllDocumentHeads(repo, rootDirectoryUrl);
+
+    // 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) {
+      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)
     const isStable = headsMapEqual(lastSeenHeads, currentHeads);
@@ -103,6 +117,20 @@ export async function waitForBidirectionalSync(
   out.taskLine(`Bidirectional sync timed out after ${(elapsed / 1000).toFixed(1)}s - document heads were still changing after ${pollCount} checks across ${lastSeenHeads.size} docs (reached ${stableCount}/${stableChecksRequired} stability checks). This may mean another peer is actively editing, or the sync server is slow to relay changes. The sync will continue but some remote changes may not be reflected yet.`, true);
 }
 
+/**
+ * Get heads from a pre-collected set of handles (cheap, synchronous reads).
+ * Used for post-push stabilization where we already know which documents changed.
+ */
+function getHandleHeads(
+  handles: DocHandle<unknown>[],
+): Map<string, string> {
+  const heads = new Map<string, string>();
+  for (const handle of handles) {
+    heads.set(getPlainUrl(handle.url), JSON.stringify(handle.heads()));
+  }
+  return heads;
+}
+
 /**
  * Get all document heads in the directory hierarchy.
  * Returns a map of document URL -> serialized heads.
@@ -139,8 +167,8 @@ async function collectHeadsRecursive(
       return;
     }
 
-    // Process all entries in the directory
-    for (const entry of doc.docs) {
+    // Process all entries in the directory concurrently
+    await Promise.all(doc.docs.map(async (entry: { type: string; url: AutomergeUrl; name: string }) => {
       if (entry.type === "folder") {
         // Recurse into subdirectory (entry.url may have stale heads)
         await collectHeadsRecursive(repo, entry.url, heads);
@@ -154,7 +182,7 @@ async function collectHeadsRecursive(
           // File document may not exist yet
         }
       }
-    }
+    }));
   } catch {
     // Directory may not exist yet
   }
@@ -179,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);