leafrelay 0.2.5 → 0.2.7

package/dist/{chunk-IOX2PULH.js → chunk-VXZVIMCG.js}

@@ -1,4 +1,4 @@
-// ../daemon/dist/chunk-PSHSXZIB.js
+// ../daemon/dist/chunk-QRLVFB6A.js
 import { createHash } from "crypto";
 import { homedir } from "os";
 import { join, resolve } from "path";
@@ -4600,6 +4600,9 @@ function write(level, args) {
 function log(...args) {
   write("info", args);
 }
+function error(...args) {
+  write("error", args);
+}
 function retryAfterMilliseconds(response, now) {
   const retryAfter = response.headers.get("retry-after");
   if (retryAfter) {
@@ -4633,7 +4636,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 () => {
@@ -4647,7 +4650,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,
@@ -4746,6 +4762,8 @@ var LeafRelayDaemonClient = class _LeafRelayDaemonClient {
   connected = false;
   closing = false;
   reconnecting;
+  reconnectTimer;
+  cancelReconnectWait;
   connectionClosed = Promise.resolve();
   initializeState;
   paths;
@@ -4759,7 +4777,15 @@ var LeafRelayDaemonClient = class _LeafRelayDaemonClient {
   clientId;
   static async connect(options) {
     const client = new _LeafRelayDaemonClient(options);
-    await client.connectTransport();
+    client.reconnecting = client.connectTransport();
+    try {
+      await client.reconnecting;
+    } catch (error2) {
+      client.close();
+      throw error2;
+    } finally {
+      client.reconnecting = void 0;
+    }
     return client;
   }
   get initializeResult() {
@@ -4769,16 +4795,42 @@ var LeafRelayDaemonClient = class _LeafRelayDaemonClient {
     return this.request(RPC_METHOD.daemonStatus);
   }
   async attachReplica(params) {
-    const result = await this.request(RPC_METHOD.replicaAttach, params);
-    this.replicas.set(result.replicaId, { params, currentId: result.replicaId });
-    return result;
+    const replicaId = randomUUID();
+    const registration = { params };
+    this.replicas.set(replicaId, registration);
+    try {
+      if (!this.connected) {
+        await this.ensureReconnected();
+      }
+      if (!registration.result) {
+        const rpc = this.rpc;
+        try {
+          await this.registerReplica(replicaId, registration);
+        } catch (error2) {
+          if (this.closing || this.rpc === rpc && this.connected) {
+            throw error2;
+          }
+          await this.ensureReconnected();
+        }
+      }
+      return registration.result;
+    } catch (error2) {
+      this.replicas.delete(replicaId);
+      throw error2;
+    }
   }
   async detachReplica(replicaId) {
+    if (!this.connected) {
+      await this.ensureReconnected();
+    }
     const registration = this.replicas.get(replicaId);
-    await this.request(RPC_METHOD.replicaDetach, { replicaId: registration?.currentId ?? replicaId });
     this.replicas.delete(replicaId);
+    await this.request(RPC_METHOD.replicaDetach, { replicaId: registration?.currentId ?? replicaId });
   }
   async resolveConflict(params) {
+    if (!this.connected) {
+      await this.ensureReconnected();
+    }
     const registration = this.replicas.get(params.replicaId);
     await this.request(RPC_METHOD.replicaResolveConflict, {
       ...params,
@@ -4786,6 +4838,9 @@ var LeafRelayDaemonClient = class _LeafRelayDaemonClient {
     });
   }
   async retry(replicaId, path2) {
+    if (!this.connected) {
+      await this.ensureReconnected();
+    }
     const registration = this.replicas.get(replicaId);
     await this.request(RPC_METHOD.replicaRetry, { replicaId: registration?.currentId ?? replicaId, path: path2 });
   }
@@ -4821,9 +4876,32 @@ var LeafRelayDaemonClient = class _LeafRelayDaemonClient {
     return decodeRpcValue(result);
   }
   async openProject(server, projectId) {
-    const result = await this.request(RPC_METHOD.projectOpen, { server, projectId });
-    this.projects.set(result.projectKey, { server, projectId, currentKey: result.projectKey });
-    return result;
+    const host = new URL(server.includes("://") ? server : `https://${server}`).host;
+    const projectKey = `${host}:${projectId}`;
+    const registration = { server, projectId, currentKey: projectKey };
+    this.projects.set(projectKey, registration);
+    try {
+      if (!this.connected) {
+        await this.ensureReconnected();
+      }
+      if (!registration.result) {
+        const rpc = this.rpc;
+        try {
+          await this.registerProject(registration);
+        } catch (error2) {
+          if (this.closing || this.rpc === rpc && this.connected) {
+            throw error2;
+          }
+          await this.ensureReconnected();
+        }
+      }
+      return registration.result;
+    } catch (error2) {
+      if (this.projects.get(projectKey) === registration) {
+        this.projects.delete(projectKey);
+      }
+      throw error2;
+    }
   }
   async closeProject(projectKey) {
     const registration = this.projects.get(projectKey);
@@ -4848,6 +4926,10 @@ var LeafRelayDaemonClient = class _LeafRelayDaemonClient {
   }
   close() {
     this.closing = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+    }
+    this.cancelReconnectWait?.();
     this.connected = false;
     this.rpc?.dispose();
     this.socket?.destroy();
@@ -4858,15 +4940,7 @@ var LeafRelayDaemonClient = class _LeafRelayDaemonClient {
     if (!this.connected) {
       await this.ensureReconnected();
     }
-    try {
-      return await this.rawRequest(method, params);
-    } catch (requestError) {
-      if (this.connected || this.closing) {
-        throw requestError;
-      }
-      await this.ensureReconnected();
-      return this.rawRequest(method, params);
-    }
+    return this.rawRequest(method, params);
   }
   rawRequest(method, params) {
     if (!this.rpc) {
@@ -4882,11 +4956,38 @@ var LeafRelayDaemonClient = class _LeafRelayDaemonClient {
     if (this.closing) {
       throw new Error("LeafRelay daemon client is closed.");
     }
-    this.reconnecting ??= this.connectTransport().finally(() => {
+    this.reconnecting ??= this.reconnectTransport().finally(() => {
       this.reconnecting = void 0;
     });
     return this.reconnecting;
   }
+  async reconnectTransport() {
+    let attempt = 0;
+    while (!this.closing) {
+      try {
+        await this.connectTransport();
+        return;
+      } catch (error2) {
+        const code = error2.code;
+        if (code === -32001 || code === -32002 || this.closing) {
+          throw error2;
+        }
+        const delay = Math.min(1e3 * 2 ** attempt++, 16e3);
+        dispatch(this.logListeners, {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          level: "warn",
+          message: `Daemon reconnection failed; retrying in ${delay}ms: ${error2 instanceof Error ? error2.message : String(error2)}`
+        });
+        await new Promise((resolveWait) => {
+          this.cancelReconnectWait = resolveWait;
+          this.reconnectTimer = setTimeout(resolveWait, delay);
+        });
+        this.cancelReconnectWait = void 0;
+        this.reconnectTimer = void 0;
+      }
+    }
+    throw new Error("LeafRelay daemon client is closed.");
+  }
   async connectTransport() {
     const metadata = await this.findOrStartDaemon();
     const socket = await tryConnect(metadata);
@@ -4909,8 +5010,19 @@ var LeafRelayDaemonClient = class _LeafRelayDaemonClient {
       this.connected = false;
       this.rpc = void 0;
       this.socket = void 0;
+      for (const registration of this.replicas.values()) {
+        registration.currentId = void 0;
+        registration.result = void 0;
+      }
+      for (const registration of this.projects.values()) {
+        registration.result = void 0;
+      }
       if (!this.closing) {
-        void this.ensureReconnected();
+        void this.ensureReconnected().catch((error2) => dispatch(this.logListeners, {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          level: "error",
+          message: `Daemon reconnection failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+        }));
       }
     });
     rpc.listen();
@@ -4922,9 +5034,10 @@ var LeafRelayDaemonClient = class _LeafRelayDaemonClient {
         clientVersion: this.options.clientVersion,
         protocolVersion: LEAFRELAY_PROTOCOL_VERSION
       });
+      await this.restoreRegistrations();
       this.connected = true;
-      await this.restoreRegistrations(rpc);
     } catch (connectError) {
+      this.connected = false;
       rpc.dispose();
       socket.destroy();
       if (this.rpc === rpc) {
@@ -4934,17 +5047,49 @@ var LeafRelayDaemonClient = class _LeafRelayDaemonClient {
       throw connectError;
     }
   }
-  async restoreRegistrations(rpc) {
+  async restoreRegistrations() {
     for (const registration of this.projects.values()) {
-      const result = await rpc.sendRequest(RPC_METHOD.projectOpen, {
-        server: registration.server,
-        projectId: registration.projectId
+      await this.registerProject(registration);
+    }
+    for (const [replicaId, registration] of this.replicas) {
+      await this.registerReplica(replicaId, registration);
+    }
+    if (this.projects.size !== 0 || this.replicas.size !== 0) {
+      dispatch(this.logListeners, {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level: "info",
+        message: `Daemon registrations restored: ${this.projects.size} project(s), ${this.replicas.size} local replica(s).`
       });
-      registration.currentKey = result.projectKey;
     }
-    for (const registration of this.replicas.values()) {
-      const result = await rpc.sendRequest(RPC_METHOD.replicaAttach, registration.params);
-      registration.currentId = result.replicaId;
+  }
+  async registerProject(registration) {
+    const rpc = this.rpc;
+    const result = await this.rawRequest(RPC_METHOD.projectOpen, {
+      server: registration.server,
+      projectId: registration.projectId
+    });
+    if (this.rpc !== rpc) {
+      throw new Error("LeafRelay daemon connection changed during project attachment.");
+    }
+    registration.currentKey = result.projectKey;
+    registration.result = result;
+  }
+  async registerReplica(replicaId, registration) {
+    const rpc = this.rpc;
+    const result = await this.rawRequest(RPC_METHOD.replicaAttach, registration.params);
+    if (this.rpc !== rpc) {
+      throw new Error("LeafRelay daemon connection changed during replica attachment.");
+    }
+    registration.currentId = result.replicaId;
+    registration.result = { ...result, replicaId };
+    dispatch(this.statusListeners, { replicaId, status: result.status });
+    for (const path2 of result.conflicts) {
+      dispatch(this.conflictListeners, {
+        replicaId,
+        path: path2,
+        conflicts: result.conflicts,
+        reason: "This path has an unresolved synchronization conflict."
+      });
     }
   }
   registerNotifications(rpc) {
@@ -5067,7 +5212,7 @@ async function tryConnect(metadata) {
 function connectCliDaemon(autoStart = true) {
   return LeafRelayDaemonClient.connect({
     clientName: "cli",
-    clientVersion: "0.2.5",
+    clientVersion: "0.2.7",
     daemonEntrypoint: new URL("./daemon.js", import.meta.url),
     autoStart
   });
@@ -5092,9 +5237,9 @@ async function startServe(directory = process.cwd()) {
         client.close();
       }
     };
-  } catch (error) {
+  } catch (error2) {
     client.close();
-    throw error;
+    throw error2;
   }
 }
 async function serve(directory = process.cwd()) {
@@ -5104,8 +5249,8 @@ async function serve(directory = process.cwd()) {
     const stop = () => {
       process.off("SIGINT", stop);
       process.off("SIGTERM", stop);
-      running.stop().then(resolveStop, (error) => {
-        console.error(error);
+      running.stop().then(resolveStop, (error2) => {
+        console.error(error2);
         resolveStop();
       });
     };
@@ -5157,4 +5302,4 @@ export {
 chokidar/index.js:
   (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=chunk-IOX2PULH.js.map
+//# sourceMappingURL=chunk-VXZVIMCG.js.map