leafrelay 0.1.6 → 0.2.0

package/dist/{chunk-MNOPLM7M.js → chunk-PRWBFOB2.js}

@@ -220,7 +220,7 @@ var OverleafRealtimeSocket = class {
         handshakeUrl.searchParams.set(name, value);
       }
       handshakeUrl.searchParams.set("t", String(Date.now()));
-      const response = await fetch(handshakeUrl, {
+      const response = await (this.options.fetch ?? fetch)(handshakeUrl, {
         headers: { origin: this.origin, cookie: this.cookie },
         redirect: "manual"
       });
@@ -373,11 +373,7 @@ var OverleafRealtimeSocket = class {
     }, delay);
   }
 };
-var overleafSocketProtocol = { encodePacket, decodePacket, decodePayload };
 var sink;
-function setLogSink(nextSink) {
-  sink = nextSink;
-}
 function write(level, args) {
   if (sink !== void 0) {
     sink(level, args);
@@ -389,57 +385,75 @@ function write(level, args) {
 function log(...args) {
   write("info", args);
 }
-function warn(...args) {
-  write("warn", args);
-}
 function error(...args) {
   write("error", args);
 }
-var globalRequestChain = Promise.resolve();
-var globalNextRequestAt = 0;
-var globalRateLimitedUntil = 0;
-var GLOBAL_MIN_REQUEST_INTERVAL_MS = 300;
-function retryAfterHeaderMs(response) {
-  const retryAfter = response.headers?.get?.("retry-after");
-  if (retryAfter !== void 0 && retryAfter !== null) {
+function retryAfterMilliseconds(response, now) {
+  const retryAfter = response.headers.get("retry-after");
+  if (retryAfter) {
     const seconds = Number(retryAfter);
     if (Number.isFinite(seconds)) {
       return Math.max(1e3, seconds * 1e3);
     }
     const retryAt = Date.parse(retryAfter);
     if (Number.isFinite(retryAt)) {
-      return Math.max(1e3, retryAt - Date.now());
+      return Math.max(1e3, retryAt - now);
     }
   }
   return 5e3;
 }
-async function queuedFetch(url, init) {
-  const previous = globalRequestChain;
-  let release;
-  globalRequestChain = new Promise((resolve6) => {
-    release = resolve6;
-  });
-  await previous;
-  try {
-    const delayMs = Math.max(
-      0,
-      globalNextRequestAt - Date.now(),
-      globalRateLimitedUntil - Date.now()
-    );
-    if (delayMs > 0) {
-      await new Promise((resolve6) => setTimeout(resolve6, delayMs));
-    }
-    globalNextRequestAt = Date.now() + GLOBAL_MIN_REQUEST_INTERVAL_MS;
-    const response = await fetch(url, init);
-    if (response.status === 429) {
-      globalRateLimitedUntil = Math.max(globalRateLimitedUntil, Date.now() + retryAfterHeaderMs(response));
-      log(`Global HTTP request queue entered rate-limit cooldown until ${new Date(globalRateLimitedUntil).toISOString()}.`);
-    }
-    return response;
-  } finally {
-    release();
+var HttpRequestScheduler = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.minimumIntervalMs = options.minimumIntervalMs ?? 300;
+    this.historyIntervalMs = options.historyIntervalMs ?? 3e3;
+    this.fetchImplementation = options.fetch ?? fetch;
+    this.now = options.now ?? Date.now;
+    this.wait = options.wait ?? ((milliseconds) => new Promise((resolveWait) => setTimeout(resolveWait, milliseconds)));
   }
-}
+  options;
+  chain = Promise.resolve();
+  nextRequestAt = 0;
+  historyNextRequestAt = 0;
+  rateLimitedUntil = 0;
+  minimumIntervalMs;
+  historyIntervalMs;
+  fetchImplementation;
+  now;
+  wait;
+  fetch(input, init) {
+    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 () => {
+      const now = this.now();
+      const readyAt = Math.max(this.nextRequestAt, this.rateLimitedUntil, history ? this.historyNextRequestAt : 0);
+      if (readyAt > now) {
+        await this.wait(readyAt - now);
+      }
+      const requestAt = this.now();
+      this.nextRequestAt = requestAt + this.minimumIntervalMs;
+      if (history) {
+        this.historyNextRequestAt = requestAt + this.historyIntervalMs;
+      }
+      const response = await this.fetchImplementation(input, init);
+      if (response.status === 429) {
+        this.rateLimitedUntil = Math.max(
+          this.rateLimitedUntil,
+          this.now() + retryAfterMilliseconds(response, this.now())
+        );
+        this.options.onRateLimit?.(this.rateLimitedUntil);
+        log(`HTTP request scheduler entered rate-limit cooldown until ${new Date(this.rateLimitedUntil).toISOString()}.`);
+      }
+      return response;
+    });
+  }
+  enqueue(operation) {
+    const result = this.chain.then(operation);
+    this.chain = result.then(() => void 0, () => void 0);
+    return result;
+  }
+};
+var sharedHttpRequestScheduler = new HttpRequestScheduler();
 function getSetCookie(res) {
   if (typeof res.headers?.getSetCookie === "function") {
     return res.headers.getSetCookie();
@@ -451,31 +465,13 @@ function getSetCookie(res) {
   return [];
 }
 var BaseAPI = class {
+  constructor(url, scheduler = sharedHttpRequestScheduler) {
+    this.scheduler = scheduler;
+    this.url = url;
+  }
+  scheduler;
   url;
   identity;
-  historyRequestChain = Promise.resolve();
-  lastHistoryRequestAt = 0;
-  isHistoryRoute(route) {
-    return route.includes("/updates?") || route.includes("/filetree/diff?") || route.includes("/diff?");
-  }
-  async waitForHistoryRequest() {
-    const previous = this.historyRequestChain;
-    let release;
-    this.historyRequestChain = new Promise((resolve6) => {
-      release = resolve6;
-    });
-    await previous;
-    try {
-      const minimumIntervalMs = 3e3;
-      const delayMs = Math.max(0, minimumIntervalMs - (Date.now() - this.lastHistoryRequestAt));
-      if (delayMs > 0) {
-        await new Promise((resolve6) => setTimeout(resolve6, delayMs));
-      }
-      this.lastHistoryRequestAt = Date.now();
-    } finally {
-      release();
-    }
-  }
   retryAfterMs(response, attempt) {
     const retryAfter = response.headers?.get?.("retry-after");
     if (retryAfter !== void 0 && retryAfter !== null) {
@@ -490,11 +486,8 @@ var BaseAPI = class {
     }
     return 5e3 * Math.pow(2, attempt);
   }
-  constructor(url) {
-    this.url = url;
-  }
   async getCsrfToken() {
-    const res = await queuedFetch(this.url + "login", {
+    const res = await this.scheduler.fetch(this.url + "login", {
       method: "GET",
       redirect: "manual"
     });
@@ -509,7 +502,7 @@ var BaseAPI = class {
     }
   }
   async getUserId(cookies) {
-    const res = await queuedFetch(this.url + "project", {
+    const res = await this.scheduler.fetch(this.url + "project", {
       method: "GET",
       redirect: "manual",
       headers: {
@@ -539,12 +532,13 @@ var BaseAPI = class {
       reconnect: true,
       reconnectionDelay: 1e3,
       reconnectionLimit: 16e3,
-      maxReconnectionAttempts: 10
+      maxReconnectionAttempts: 10,
+      fetch: (input, init) => this.scheduler.fetch(input, init)
     });
   }
   async passportLogin(email, password) {
     const identity = await this.getCsrfToken();
-    const res = await queuedFetch(this.url + "login", {
+    const res = await this.scheduler.fetch(this.url + "login", {
       method: "POST",
       redirect: "manual",
       headers: {
@@ -603,7 +597,7 @@ var BaseAPI = class {
     }
   }
   async updateCookies(identity) {
-    const res = await queuedFetch(this.url + "socket.io/socket.io.js", {
+    const res = await this.scheduler.fetch(this.url + "socket.io/socket.io.js", {
       method: "GET",
       redirect: "manual",
       headers: {
@@ -645,13 +639,10 @@ var BaseAPI = class {
     let lastError = {};
     for (let attempt = 0; attempt <= MAX_HTTP_RETRIES; attempt++) {
       try {
-        if (this.isHistoryRoute(route)) {
-          await this.waitForHistoryRequest();
-        }
         let res = void 0;
         switch (type) {
           case "GET":
-            res = await queuedFetch(this.url + route, {
+            res = await this.scheduler.fetch(this.url + route, {
               method: "GET",
               redirect: "manual",
               headers: {
@@ -667,7 +658,7 @@ var BaseAPI = class {
               _csrf: this.identity.csrfToken,
               ...body
             });
-            res = await queuedFetch(this.url + route, {
+            res = await this.scheduler.fetch(this.url + route, {
               method: "POST",
               redirect: "manual",
               headers: {
@@ -682,7 +673,7 @@ var BaseAPI = class {
           case "PUT":
             break;
           case "DELETE":
-            res = await queuedFetch(this.url + route, {
+            res = await this.scheduler.fetch(this.url + route, {
               method: "DELETE",
               redirect: "manual",
               headers: {
@@ -749,7 +740,7 @@ var BaseAPI = class {
     }
     let content = [];
     while (true) {
-      const res = await queuedFetch(this.url + route, {
+      const res = await this.scheduler.fetch(this.url + route, {
         method: "GET",
         redirect: "manual",
         headers: {
@@ -1030,7 +1021,7 @@ var BaseAPI = class {
     }
     let content = [];
     while (true) {
-      const res = await queuedFetch(absoluteUrl, {
+      const res = await this.scheduler.fetch(absoluteUrl, {
         method: "GET",
         redirect: "manual",
         headers
@@ -1517,14 +1508,8 @@ var SocketIOAPI = class _SocketIOAPI {
     });
   }
 };
-var FolderKeys = {
-  folder: "folders",
-  doc: "docs",
-  file: "fileRefs",
-  outputs: "outputs"
-};
 function configPath(environment = process.env) {
-  return environment.LEAFRELAY_CONFIG ? resolve(environment.LEAFRELAY_CONFIG) : join(homedir(), ".leafrelay", "config.json");
+  return environment.LEAFRELAY_CONFIG ? resolve(environment.LEAFRELAY_CONFIG) : join(environment.LEAFRELAY_HOME ? resolve(environment.LEAFRELAY_HOME) : join(homedir(), ".leafrelay"), "config.json");
 }
 function normalizeServerUrl(value) {
   const url = new URL(value.includes("://") ? value : `https://${value}`);
@@ -1545,7 +1530,7 @@ async function readConfig(path = configPath()) {
     return parsed;
   } catch (error2) {
     if (error2.code === "ENOENT") {
-      return { version: 1, servers: {} };
+      return { version: 1, servers: {}, knownServers: {} };
     }
     throw error2;
   }
@@ -1558,7 +1543,29 @@ async function writeConfig(config, path = configPath()) {
 }
 async function saveServerSession(session, path = configPath()) {
   const config = await readConfig(path);
-  config.servers[serverKey(session.url)] = session;
+  const key = serverKey(session.url);
+  config.servers[key] = session;
+  config.knownServers ??= {};
+  config.knownServers[key] ??= { name: key, url: session.url };
+  await writeConfig(config, path);
+}
+async function saveKnownServer(name, url, path = configPath()) {
+  const config = await readConfig(path);
+  const key = serverKey(url);
+  config.knownServers ??= {};
+  config.knownServers[key] = { name, url: normalizeServerUrl(url) };
+  await writeConfig(config, path);
+}
+async function removeKnownServer(server, path = configPath()) {
+  const config = await readConfig(path);
+  const key = serverKey(server);
+  delete config.servers[key];
+  delete config.knownServers?.[key];
+  await writeConfig(config, path);
+}
+async function removeServerSession(server, path = configPath()) {
+  const config = await readConfig(path);
+  delete config.servers[serverKey(server)];
   await writeConfig(config, path);
 }
 async function getServerSession(server, environment = process.env, path = configPath(environment)) {
@@ -1744,11 +1751,12 @@ function textContent(content) {
   }
 }
 var RemoteProject = class {
-  constructor(url, projectId, cookies) {
+  constructor(url, projectId, cookies, transport) {
     this.url = url;
     this.projectId = projectId;
     this.cookies = cookies;
-    this.api = new BaseAPI(url);
+    this.externalTransport = transport;
+    this.api = transport?.api ?? new BaseAPI(url);
   }
   url;
   projectId;
@@ -1760,19 +1768,27 @@ var RemoteProject = class {
   entries = /* @__PURE__ */ new Map();
   idToPath = /* @__PURE__ */ new Map();
   changeHandler;
+  externalTransport;
   async connect() {
-    const login = await this.api.cookiesLogin(this.cookies);
-    if (login.type !== "success" || !login.identity) {
-      throw new Error(login.message || `Authentication to ${this.url} failed.`);
+    if (this.externalTransport) {
+      this.identity = this.externalTransport.identity;
+      this.socket = this.externalTransport.socket;
+    } else {
+      const login = await this.api.cookiesLogin(this.cookies);
+      if (login.type !== "success" || !login.identity) {
+        throw new Error(login.message || `Authentication to ${this.url} failed.`);
+      }
+      this.identity = login.identity;
+      this.socket = new SocketIOAPI(this.url, this.api, this.identity, this.projectId);
     }
-    this.identity = login.identity;
-    this.socket = new SocketIOAPI(this.url, this.api, this.identity, this.projectId);
     this.project = await this.socket.joinProject(this.projectId);
     this.reindex();
     this.registerEvents();
   }
   disconnect() {
-    this.socket?.disconnect();
+    if (!this.externalTransport) {
+      this.socket?.disconnect();
+    }
   }
   onChange(handler) {
     this.changeHandler = handler;
@@ -2205,6 +2221,49 @@ var SyncEngine = class {
     await this.stopLocalWatch?.();
     await this.queue;
   }
+  getConflicts() {
+    return [...this.conflicts].sort();
+  }
+  async resolveConflict(path, winner) {
+    const normalized = normalizePath2(path);
+    if (!this.conflicts.has(normalized)) {
+      throw new Error(`No unresolved conflict exists for ${normalized}.`);
+    }
+    await this.enqueue(async () => {
+      const remoteEntry = this.options.remote.entry(normalized);
+      if (winner === "local") {
+        const localContent = await this.options.local.read(normalized);
+        if (localContent) {
+          await this.options.remote.write(normalized, localContent);
+          const synchronized = await this.options.remote.read(normalized);
+          if (sha256(synchronized) !== sha256(localContent)) {
+            await this.options.local.write(normalized, synchronized);
+          }
+          updateSyncCheckpoint(this.state, normalized, synchronized);
+        } else {
+          if (remoteEntry) {
+            await this.options.remote.remove(normalized);
+          }
+          removeSyncCheckpoint(this.state, normalized);
+        }
+      } else if (isRemoteFile(remoteEntry)) {
+        const remoteContent = await this.options.remote.read(normalized);
+        await this.options.local.write(normalized, remoteContent);
+        updateSyncCheckpoint(this.state, normalized, remoteContent);
+      } else {
+        await this.options.local.remove(normalized);
+        removeSyncCheckpoint(this.state, normalized);
+      }
+      await this.options.stateStore.save(this.state);
+      this.conflicts.delete(normalized);
+      this.options.log(`Resolved ${normalized} using ${winner === "local" ? "local" : "Overleaf"} content.`);
+    });
+  }
+  async retry(path) {
+    const normalized = normalizePath2(path);
+    this.conflicts.delete(normalized);
+    await this.enqueue(() => this.reconcilePath(normalized, "local"));
+  }
   async startupReconcile(currentVersion, localFiles, remoteFiles) {
     const state = this.state;
     if (state.remoteVersion > currentVersion) {
@@ -2256,11 +2315,14 @@ var SyncEngine = class {
         this.options.log(`Failed to synchronize ${path}: ${error2 instanceof Error ? error2.message : String(error2)}`);
       }
     }
-    if (failed || this.conflicts.size !== 0) {
-      throw new Error(`Synchronization paused for ${failed ? "failed" : "conflicting"} paths; successful paths were checkpointed.`);
+    if (failed) {
+      throw new Error("Synchronization paused for failed paths; successful paths were checkpointed.");
     }
     state.remoteVersion = currentVersion;
     await this.options.stateStore.save(state);
+    if (this.conflicts.size !== 0) {
+      this.options.log(`Synchronization remains active; ${this.conflicts.size} conflicting path(s) are paused.`);
+    }
   }
   schedule(path, source) {
     const normalized = normalizePath2(path);
@@ -2278,6 +2340,11 @@ var SyncEngine = class {
       });
     }, 250));
   }
+  enqueue(operation) {
+    const result = this.queue.then(operation);
+    this.queue = result.then(() => void 0, () => void 0);
+    return result;
+  }
   async reconcilePath(path, source) {
     const normalized = normalizePath2(path);
     if (this.shouldIgnore(normalized) || this.conflicts.has(normalized)) {
@@ -2391,15 +2458,15 @@ var FileSyncStateStore = class {
     this.serialized = serialized;
   }
 };
-async function startServe(directory = process.cwd()) {
+async function startServe(directory = process.cwd(), options = {}) {
   const root = resolve5(directory);
   const settings = await readProjectSettings(root);
   const session = await getServerSession(settings.serverName);
   if (!session) {
     throw new Error(`No login is stored for ${settings.serverName}. Run: leafrelay login ${settings.serverName}`);
   }
-  const cookie = process.env.LEAFRELAY_COOKIE || session.identity.cookies;
-  const remote = new RemoteProject(session.url || settings.serverUrl, settings.projectId, cookie);
+  const cookie = options.cookie || process.env.LEAFRELAY_COOKIE || session.identity.cookies;
+  const remote = options.remote ?? new RemoteProject(session.url || settings.serverUrl, settings.projectId, cookie);
   await remote.connect();
   const configuredPatterns = settings.localReplica.settings["ignore-patterns"];
   const ignore = createIgnoreMatcher(configuredPatterns);
@@ -2410,10 +2477,10 @@ async function startServe(directory = process.cwd()) {
     remote,
     stateStore: new FileSyncStateStore(root, settings.uri),
     ignore,
-    log,
-    onConflict: (path, reason) => {
-      log(`Conflict paused for ${path}: ${reason}`);
-    }
+    log: options.log ?? log,
+    onConflict: options.onConflict ?? ((path, reason) => {
+      (options.log ?? log)(`Conflict paused for ${path}: ${reason}`);
+    })
   });
   try {
     await engine.start();
@@ -2421,8 +2488,15 @@ async function startServe(directory = process.cwd()) {
     remote.disconnect();
     throw error2;
   }
-  log(`LeafRelay is serving ${root} (${settings.projectName}).`);
+  (options.log ?? log)(`LeafRelay is serving ${root} (${settings.projectName}).`);
   return {
+    root,
+    serverName: settings.serverName,
+    projectId: settings.projectId,
+    projectName: settings.projectName,
+    conflicts: () => engine.getConflicts(),
+    resolveConflict: (path, winner) => engine.resolveConflict(path, winner),
+    retry: (path) => engine.retry(path),
     stop: async () => {
       await engine.stop();
       remote.disconnect();
@@ -2431,39 +2505,20 @@ async function startServe(directory = process.cwd()) {
 }
 
 export {
-  OverleafRealtimeSocket,
-  overleafSocketProtocol,
-  setLogSink,
-  log,
-  warn,
-  error,
-  BaseAPI,
+  HttpRequestScheduler,
   ExtendedBaseAPI,
   SocketIOAPI,
-  FolderKeys,
   configPath,
   normalizeServerUrl,
   serverKey,
   readConfig,
-  writeConfig,
   saveServerSession,
+  saveKnownServer,
+  removeKnownServer,
+  removeServerSession,
   getServerSession,
-  NodeReplicaFileSystem,
   readProjectSettings,
-  DEFAULT_IGNORE_PATTERNS,
-  createIgnoreMatcher,
   RemoteProject,
-  encodeTextBase,
-  mergeText,
-  SYNC_STATE_SCHEMA_VERSION,
-  sha256,
-  parseSyncState,
-  createSyncState,
-  updateSyncCheckpoint,
-  removeSyncCheckpoint,
-  readTextBase,
-  SyncEngine,
-  FileSyncStateStore,
   startServe
 };
-//# sourceMappingURL=chunk-MNOPLM7M.js.map
+//# sourceMappingURL=chunk-PRWBFOB2.js.map