leafrelay 0.2.5 → 0.2.7

package/dist/{chunk-OZ4FLSVP.js → chunk-3TTRDNHP.js}

@@ -160,6 +160,7 @@ var OverleafRealtimeSocket = class {
   reconnectAttempts = 0;
   reconnectTimer;
   inactivityTimer;
+  connectionAbort;
   closeTimeoutMs = 6e4;
   acknowledgementId = 0;
   acknowledgements = /* @__PURE__ */ new Map();
@@ -225,6 +226,12 @@ var OverleafRealtimeSocket = class {
     return this;
   }
   async connect() {
+    if (this.explicitlyDisconnected) {
+      return;
+    }
+    const controller = new AbortController();
+    this.connectionAbort?.abort();
+    this.connectionAbort = controller;
     try {
       this.projectJoined = false;
       const handshakeUrl = new URL("/socket.io/1/", this.endpoint.origin);
@@ -234,7 +241,8 @@ var OverleafRealtimeSocket = class {
       handshakeUrl.searchParams.set("t", String(Date.now()));
       const response = await (this.options.fetch ?? fetch)(handshakeUrl, {
         headers: { origin: this.origin, cookie: this.cookie },
-        redirect: "manual"
+        redirect: "manual",
+        signal: AbortSignal.any([controller.signal, AbortSignal.timeout(15e3)])
       });
       if (!response.ok) {
         throw new Error(`Socket.IO handshake failed: HTTP ${response.status} ${await response.text()}`);
@@ -249,22 +257,50 @@ var OverleafRealtimeSocket = class {
       const websocketUrl = new URL(`/socket.io/1/websocket/${sessionId}`, this.endpoint.origin);
       websocketUrl.protocol = websocketUrl.protocol === "https:" ? "wss:" : "ws:";
       websocketUrl.search = this.endpoint.search;
-      this.socket = new WebSocket(websocketUrl, {
+      if (controller.signal.aborted) {
+        return;
+      }
+      const socket = new WebSocket(websocketUrl, {
         headers: { origin: this.origin, cookie: this.cookie }
       });
-      this.socket.addEventListener("open", () => this.events.emit("connecting", "websocket"));
-      this.socket.addEventListener("message", (event) => void this.receive(event.data));
-      this.socket.addEventListener("error", (error2) => this.events.emit("error", error2));
-      this.socket.addEventListener("close", (event) => this.handleClose(event));
+      this.socket = socket;
+      socket.addEventListener("open", () => {
+        if (this.socket !== socket) {
+          return;
+        }
+        this.resetInactivityTimer();
+        this.events.emit("connecting", "websocket");
+      });
+      socket.addEventListener("message", (event) => {
+        if (this.socket === socket) {
+          void this.receive(event.data, socket);
+        }
+      });
+      socket.addEventListener("error", (error2) => {
+        if (this.socket === socket) {
+          this.events.emit("error", error2);
+        }
+      });
+      socket.addEventListener("close", (event) => {
+        if (this.socket === socket) {
+          this.handleClose(event);
+        }
+      });
     } catch (error2) {
+      if (controller.signal.aborted) {
+        return;
+      }
       this.events.emit("connect_failed", error2);
       this.events.emit("error", error2);
       this.scheduleReconnect();
     }
   }
-  async receive(data) {
+  async receive(data, socket) {
     this.resetInactivityTimer();
     const value = typeof data === "string" ? data : data instanceof Blob ? await data.text() : Buffer.from(data).toString("utf8");
+    if (this.socket !== socket) {
+      return;
+    }
     for (const packet of decodePayload(value)) {
       this.handlePacket(packet);
     }
@@ -339,6 +375,7 @@ var OverleafRealtimeSocket = class {
   }
   handleClose(event) {
     const wasConnected = this.connected;
+    this.socket = void 0;
     this.connected = false;
     this.projectJoined = false;
     if (this.inactivityTimer) {
@@ -353,6 +390,8 @@ var OverleafRealtimeSocket = class {
     this.scheduleReconnect();
   }
   closeSocket(reason) {
+    this.connectionAbort?.abort();
+    this.connectionAbort = void 0;
     const wasConnected = this.connected;
     this.connected = false;
     this.projectJoined = false;
@@ -381,7 +420,7 @@ var OverleafRealtimeSocket = class {
     if (!this.reconnectEnabled || this.explicitlyDisconnected || this.reconnectTimer) {
       return;
     }
-    const maxAttempts = this.options.maxReconnectionAttempts ?? 10;
+    const maxAttempts = this.options.maxReconnectionAttempts ?? Infinity;
     if (this.reconnectAttempts >= maxAttempts) {
       this.events.emit("reconnect_failed");
       return;
@@ -398,6 +437,9 @@ var OverleafRealtimeSocket = class {
   }
 };
 var sink;
+function setLogSink(nextSink) {
+  sink = nextSink;
+}
 function write(level, args) {
   if (sink !== void 0) {
     sink(level, args);
@@ -445,7 +487,7 @@ var HttpRequestScheduler = class {
   fetchImplementation;
   now;
   wait;
-  fetch(input, init) {
+  fetch(input, init, timeoutMs = this.options.requestTimeoutMs ?? 6e4) {
     const url = input instanceof Request ? input.url : String(input);
     const history = url.includes("/updates?") || url.includes("/filetree/diff?") || url.includes("/diff?");
     return this.enqueue(async () => {
@@ -459,7 +501,20 @@ var HttpRequestScheduler = class {
       if (history) {
         this.historyNextRequestAt = requestAt + this.historyIntervalMs;
       }
-      const response = await this.fetchImplementation(input, init);
+      const timeout = AbortSignal.timeout(timeoutMs);
+      const signals = [timeout, init?.signal, input instanceof Request ? input.signal : void 0].filter((signal) => Boolean(signal));
+      let response;
+      try {
+        response = await this.fetchImplementation(input, { ...init, signal: AbortSignal.any(signals) });
+      } catch (error2) {
+        const destination = new URL(url);
+        error("HTTP request failed", {
+          method: init?.method ?? (input instanceof Request ? input.method : "GET"),
+          url: `${destination.origin}${destination.pathname}`,
+          error: error2
+        });
+        throw error2;
+      }
       if (response.status === 429) {
         this.rateLimitedUntil = Math.max(
           this.rateLimitedUntil,
@@ -655,7 +710,7 @@ var BaseAPI = class {
     }
     return false;
   }
-  async request(type, route, body, callback, extraHeaders) {
+  async request(type, route, body, callback, extraHeaders, timeoutMs) {
     if (this.identity === void 0) {
       return Promise.reject();
     }
@@ -674,7 +729,7 @@ var BaseAPI = class {
                 "Cookie": this.identity.cookies,
                 ...extraHeaders
               }
-            });
+            }, timeoutMs);
             break;
           case "POST":
             const content_type = body instanceof FormData ? void 0 : { "Content-Type": "application/json" };
@@ -692,7 +747,7 @@ var BaseAPI = class {
                 ...extraHeaders
               },
               body: raw_body
-            });
+            }, timeoutMs);
             break;
           case "PUT":
             break;
@@ -706,7 +761,7 @@ var BaseAPI = class {
                 "X-Csrf-Token": this.identity.csrfToken,
                 ...extraHeaders
               }
-            });
+            }, timeoutMs);
             break;
         }
         ;
@@ -956,7 +1011,7 @@ var BaseAPI = class {
     return this.request("POST", `project/${projectId}/compile?auto_compile=true`, body, (res) => {
       const compile = JSON.parse(res);
       return { compile };
-    }, { "X-Csrf-Token": identity.csrfToken });
+    }, { "X-Csrf-Token": identity.csrfToken }, 3e5);
   }
   async stopCompile(identity, projectId) {
     this.setIdentity(identity);
@@ -2394,18 +2449,30 @@ var SyncEngine = class {
   stopRemoteReconnect;
   eventTimers = /* @__PURE__ */ new Map();
   stopped = false;
+  failedPaths = /* @__PURE__ */ new Map();
+  retryTimer;
+  retryDelayMs = 3e4;
+  pendingRemoteVersion;
+  pendingInitialization = false;
+  get syncError() {
+    if (this.failedPaths.size === 0) {
+      return void 0;
+    }
+    const [path, failure] = this.failedPaths.entries().next().value;
+    return `${this.failedPaths.size} path(s) could not synchronize, including ${path}: ${failure.message}. Other paths remain active; failed paths will retry automatically.`;
+  }
   async start() {
     this.stopped = false;
-    this.state = await this.options.stateStore.load();
-    const currentVersion = await this.options.remote.getCurrentVersion();
-    const localFiles = await this.options.local.listFiles();
-    const remoteFiles = this.remoteFilePaths();
-    if (!this.state || !this.state.initialized) {
-      await this.initializeState(currentVersion, localFiles, remoteFiles);
-    } else {
-      this.restoreConflicts();
-      await this.startupReconcile(currentVersion, localFiles, remoteFiles);
+    const startup = this.enqueue(() => this.initialize());
+    try {
+      await startup;
+    } catch (error2) {
+      await this.stop();
+      throw error2;
     }
+  }
+  async initialize() {
+    this.state = await this.options.stateStore.load();
     this.stopLocalWatch = await this.options.local.watch((path) => this.schedule(path, "local"));
     this.stopRemoteChange = this.options.remote.onChange((change) => {
       if (this.stopped) {
@@ -2424,10 +2491,24 @@ var SyncEngine = class {
         this.options.log(`Failed to reconcile after reconnecting: ${error2 instanceof Error ? error2.message : String(error2)}`);
       });
     });
-    this.options.log(`Synchronization active at Overleaf version ${this.state.remoteVersion}.`);
+    const currentVersion = await this.options.remote.getCurrentVersion();
+    const localFiles = await this.options.local.listFiles();
+    const remoteFiles = this.remoteFilePaths();
+    this.options.log(`Checking replica at Overleaf version ${currentVersion}: ${localFiles.length} local file(s), ${remoteFiles.length} remote file(s).`);
+    if (!this.state || !this.state.initialized) {
+      await this.initializeState(currentVersion, localFiles, remoteFiles);
+    } else {
+      this.restoreConflicts();
+      await this.startupReconcile(currentVersion, localFiles, remoteFiles);
+    }
+    this.options.log(this.syncError ? `Synchronization active with pending retries. ${this.syncError}` : `Synchronization active at Overleaf version ${this.state.remoteVersion}.`);
   }
   async stop() {
     this.stopped = true;
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = void 0;
+    }
     this.stopRemoteChange?.();
     this.stopRemoteChange = void 0;
     this.stopRemoteReconnect?.();
@@ -2501,21 +2582,25 @@ var SyncEngine = class {
       await this.options.stateStore.save(this.state);
     }
     this.restoreConflicts();
+    this.pendingRemoteVersion = currentVersion;
+    this.pendingInitialization = true;
     const paths = /* @__PURE__ */ new Set([...localFiles, ...remoteFiles, ...Object.keys(this.state.files)]);
     for (const path of [...paths].sort()) {
       const normalized = normalizePath2(path);
       if (this.conflicts.has(normalized)) {
         continue;
       }
-      if (this.state.files[normalized] !== void 0) {
-        await this.reconcilePath(normalized, "local");
-        continue;
+      try {
+        if (this.state.files[normalized] !== void 0) {
+          await this.synchronizePath(normalized, "local");
+        } else {
+          await this.initializePath(normalized);
+        }
+      } catch (error2) {
+        this.recordFailure(normalized, "local", error2);
       }
-      await this.initializePath(normalized);
     }
-    this.state.remoteVersion = currentVersion;
-    this.state.initialized = true;
-    await this.options.stateStore.save(this.state);
+    await this.finishRemoteBatch();
     if (this.conflicts.size !== 0) {
       this.options.log(`Synchronization remains active; ${this.conflicts.size} conflicting path(s) are paused.`);
     }
@@ -2588,7 +2673,7 @@ var SyncEngine = class {
         throw new Error("Synchronization paused: Overleaf history is unavailable, so remote changes cannot be distinguished safely.");
       }
     }
-    const candidates = new Set(localChanged);
+    const candidates = /* @__PURE__ */ new Set([...localChanged, ...this.failedPaths.keys()]);
     const knownFiles = /* @__PURE__ */ new Set([...Object.keys(state.files), ...localFiles, ...remoteFiles]);
     for (const path of [...localFiles, ...remoteFiles]) {
       if (state.files[path] === void 0) {
@@ -2596,6 +2681,9 @@ var SyncEngine = class {
       }
     }
     for (const change of remoteDiff.diff) {
+      if (!change.operation) {
+        continue;
+      }
       const paths = [change.pathname, change.newPathname].filter((path) => Boolean(path));
       for (const changedPath of paths.map(normalizePath2)) {
         let matched = false;
@@ -2610,20 +2698,19 @@ var SyncEngine = class {
         }
       }
     }
-    let failed = false;
+    this.pendingRemoteVersion = currentVersion;
+    this.options.log(`Reconciling ${candidates.size} changed path(s).`);
     for (const path of [...candidates].sort()) {
+      if (this.stopped) {
+        return;
+      }
       try {
-        await this.reconcilePath(path, localChanged.has(path) ? "local" : "remote");
+        await this.synchronizePath(path, localChanged.has(path) ? "local" : "remote");
       } catch (error2) {
-        failed = true;
-        this.options.log(`Failed to synchronize ${path}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        this.recordFailure(path, localChanged.has(path) ? "local" : "remote", error2);
       }
     }
-    if (failed) {
-      throw new Error("Synchronization paused for failed paths; successful paths were checkpointed.");
-    }
-    state.remoteVersion = currentVersion;
-    await this.options.stateStore.save(state);
+    await this.finishRemoteBatch();
     if (this.conflicts.size !== 0) {
       this.options.log(`Synchronization remains active; ${this.conflicts.size} conflicting path(s) are paused.`);
     }
@@ -2638,7 +2725,7 @@ var SyncEngine = class {
       await this.options.local.listFiles(),
       this.remoteFilePaths()
     );
-    this.options.log(`Realtime connection restored at Overleaf version ${currentVersion}.`);
+    this.options.log(this.syncError ? `Realtime connection restored; ${this.syncError}` : `Realtime connection restored at Overleaf version ${currentVersion}.`);
   }
   schedule(path, source, actor) {
     const normalized = normalizePath2(path);
@@ -2668,13 +2755,72 @@ var SyncEngine = class {
           return;
         }
         const remoteActor = pending.unknownRemoteActor ? void 0 : pending.actors.size === 1 ? [...pending.actors][0] : pending.actors.size > 1 ? "multiple Overleaf collaborators" : void 0;
-        this.queue = this.queue.then(() => this.reconcilePath(normalized, pending.source, remoteActor)).catch((error2) => {
-          this.options.log(`Failed to synchronize ${normalized}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        this.queue = this.queue.then(() => this.synchronizePath(normalized, pending.source, remoteActor)).catch((error2) => {
+          this.recordFailure(normalized, pending.source, error2, remoteActor);
         });
       }, 250)
     };
     this.eventTimers.set(normalized, pending);
   }
+  async synchronizePath(path, source, actor) {
+    if (this.pendingInitialization && this.state.files[path] === void 0) {
+      await this.initializePath(path);
+    } else {
+      await this.reconcilePath(path, source, actor);
+    }
+    if (this.failedPaths.delete(path)) {
+      this.options.onSyncError?.(this.syncError);
+    }
+  }
+  recordFailure(path, source, error2, actor) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    this.failedPaths.set(path, { source, actor, message });
+    this.options.log(`Failed to synchronize ${path}: ${message}; retrying without stopping other paths.`);
+    this.options.onSyncError?.(this.syncError);
+    this.scheduleRetry();
+  }
+  scheduleRetry() {
+    if (this.stopped || this.retryTimer || this.failedPaths.size === 0) {
+      return;
+    }
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = void 0;
+      void this.enqueue(async () => {
+        if (this.stopped) {
+          return;
+        }
+        for (const [path, failure] of [...this.failedPaths]) {
+          if (this.stopped) {
+            return;
+          }
+          try {
+            await this.synchronizePath(path, failure.source, failure.actor);
+            this.options.log(`Recovered synchronization for ${path}.`);
+          } catch (error2) {
+            const message = error2 instanceof Error ? error2.message : String(error2);
+            this.failedPaths.set(path, { ...failure, message });
+            this.options.log(`Retry failed for ${path}: ${message}`);
+          }
+        }
+        await this.finishRemoteBatch();
+      }).catch((error2) => this.options.log(`Could not checkpoint retry batch: ${String(error2)}`)).finally(() => {
+        this.retryDelayMs = this.failedPaths.size ? Math.min(this.retryDelayMs * 2, 12e4) : 3e4;
+        this.scheduleRetry();
+      });
+    }, this.retryDelayMs);
+  }
+  async finishRemoteBatch() {
+    if (this.stopped || this.failedPaths.size || this.pendingRemoteVersion === void 0) {
+      return;
+    }
+    this.state.remoteVersion = this.pendingRemoteVersion;
+    if (this.pendingInitialization) {
+      this.state.initialized = true;
+    }
+    await this.options.stateStore.save(this.state);
+    this.pendingRemoteVersion = void 0;
+    this.pendingInitialization = false;
+  }
   enqueue(operation) {
     const result = this.queue.then(operation);
     this.queue = result.then(() => void 0, () => void 0);
@@ -3137,6 +3283,7 @@ async function startServe(directory = process.cwd(), options = {}) {
     remote,
     stateStore: new FileSyncStateStore(root, settings.uri),
     ignore,
+    onSyncError: options.onSyncError,
     log: options.log ?? log,
     onConflict: options.onConflict ?? ((path, reason) => {
       (options.log ?? log)(`Conflict paused for ${path}: ${reason}`);
@@ -3154,6 +3301,7 @@ async function startServe(directory = process.cwd(), options = {}) {
     serverName: settings.serverName,
     projectId: settings.projectId,
     projectName: settings.projectName,
+    syncError: () => engine.syncError,
     conflicts: () => engine.getConflicts(),
     resolveConflict: (path, winner) => engine.resolveConflict(path, winner),
     retry: (path) => engine.retry(path),
@@ -3165,6 +3313,7 @@ async function startServe(directory = process.cwd(), options = {}) {
 }
 
 export {
+  setLogSink,
   HttpRequestScheduler,
   ExtendedBaseAPI,
   SocketIOAPI,
@@ -3181,4 +3330,4 @@ export {
   RemoteProject,
   startServe
 };
-//# sourceMappingURL=chunk-OZ4FLSVP.js.map
+//# sourceMappingURL=chunk-3TTRDNHP.js.map