leafrelay 0.2.2 → 0.2.4

package/dist/cli.js

@@ -5,11 +5,11 @@ import {
   daemonStatus,
   daemonStop,
   serve
-} from "./chunk-2EXJYAER.js";
+} from "./chunk-Y543FNFD.js";
 import {
   configPath,
   normalizeServerUrl
-} from "./chunk-Q3R5N4YE.js";
+} from "./chunk-OZ4FLSVP.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -48,7 +48,7 @@ async function login(server, options) {
 }
 
 // src/cli.ts
-var program = new Command().name("leafrelay").description("Keep a local directory synchronized with an Overleaf project.").version("0.2.2");
+var program = new Command().name("leafrelay").description("Keep a local directory synchronized with an Overleaf project.").version("0.2.4");
 program.command("login").description("Authenticate to Overleaf and save the session in ~/.leafrelay/config.json.").argument("[server]", "Overleaf server URL", "https://www.overleaf.com/").option("--cookie <cookie>", "Overleaf browser cookie").option("--email <email>", "Overleaf account email").option("--password <password>", "Overleaf account password").action(login);
 program.command("serve").description("Synchronize the current directory with its configured Overleaf project.").argument("[directory]", "Local replica directory", process.cwd()).action(serve);
 var daemon = program.command("daemon").description("Inspect or control the shared LeafRelay daemon.");

package/dist/daemon.js

@@ -13,10 +13,10 @@ import {
   saveServerSession,
   serverKey,
   startServe
-} from "./chunk-Q3R5N4YE.js";
+} from "./chunk-OZ4FLSVP.js";
 
 // ../daemon/src/server.ts
-import { randomBytes } from "crypto";
+import { randomBytes, randomUUID as randomUUID2 } from "crypto";
 import { appendFile, chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
 import { createServer } from "net";
 
@@ -97,7 +97,6 @@ function decodeRpcValue(value) {
 }
 
 // ../daemon/src/networkRuntime.ts
-var PROJECT_IDLE_MS = 6e4;
 var SERVER_OPERATIONS = /* @__PURE__ */ new Set([
   "userProjectsJson",
   "getProjectsJson",
@@ -256,10 +255,6 @@ var NetworkRuntimeRegistry = class {
   async openProject(clientId, server2, projectId) {
     const runtime = await this.getOrCreateProject(server2, projectId);
     const shared = runtime.owners.size !== 0 || runtime.replicaReferences !== 0;
-    if (runtime.idleTimer) {
-      clearTimeout(runtime.idleTimer);
-      runtime.idleTimer = void 0;
-    }
     runtime.owners.add(clientId);
     await runtime.ready;
     return { projectKey: runtime.key, shared };
@@ -294,10 +289,6 @@ var NetworkRuntimeRegistry = class {
   }
   async acquireReplica(server2, projectId) {
     const runtime = await this.getOrCreateProject(server2, projectId);
-    if (runtime.idleTimer) {
-      clearTimeout(runtime.idleTimer);
-      runtime.idleTimer = void 0;
-    }
     runtime.replicaReferences += 1;
     await runtime.ready;
     let released = false;
@@ -386,7 +377,7 @@ var NetworkRuntimeRegistry = class {
       onFileRemoved: (...args) => emit("onFileRemoved", ...args),
       onFileMoved: (...args) => emit("onFileMoved", ...args),
       onFileChanged: (...args) => emit("onFileChanged", ...args),
-      onDisconnected: () => emit("onDisconnected"),
+      onDisconnected: (reason) => emit("onDisconnected", reason),
       onConnectionAccepted: (...args) => emit("onConnectionAccepted", ...args),
       onClientUpdated: (...args) => emit("onClientUpdated", ...args),
       onClientDisconnected: (...args) => emit("onClientDisconnected", ...args),
@@ -416,7 +407,8 @@ var NetworkRuntimeRegistry = class {
       remove: (path) => this.enqueueProjectOperation(runtime, () => runtime.remote.remove(path)),
       getCurrentVersion: () => this.enqueueProjectOperation(runtime, () => runtime.remote.getCurrentVersion()),
       getFileTreeDiff: (from, to) => this.enqueueProjectOperation(runtime, () => runtime.remote.getFileTreeDiff(from, to)),
-      onChange: (handler) => runtime.remote.onChange(handler)
+      onChange: (handler) => runtime.remote.onChange(handler),
+      onReconnect: (handler) => runtime.remote.onReconnect(handler)
     };
   }
   enqueueProjectOperation(runtime, operation) {
@@ -425,19 +417,15 @@ var NetworkRuntimeRegistry = class {
     return result;
   }
   scheduleProjectStop(runtime) {
-    if (runtime.owners.size !== 0 || runtime.replicaReferences !== 0 || runtime.idleTimer) {
+    if (runtime.owners.size !== 0 || runtime.replicaReferences !== 0) {
       return;
     }
-    runtime.idleTimer = setTimeout(() => void this.stopProject(runtime), PROJECT_IDLE_MS);
-    runtime.idleTimer.unref();
+    void this.stopProject(runtime);
   }
   async stopProject(runtime) {
     if (!this.projects.delete(runtime.key)) {
       return;
     }
-    if (runtime.idleTimer) {
-      clearTimeout(runtime.idleTimer);
-    }
     runtime.socket.disconnect();
   }
 };
@@ -446,7 +434,6 @@ var NetworkRuntimeRegistry = class {
 import { randomUUID } from "crypto";
 import { realpath } from "fs/promises";
 import { resolve as resolve2 } from "path";
-var DETACHED_REPLICA_GRACE_MS = 6e4;
 var ReplicaAlreadyActiveError = class extends Error {
   constructor(projectId, activeRoot, requestedRoot) {
     super(`Overleaf project ${projectId} is already synchronized by ${activeRoot}; ${requestedRoot} cannot become a second writable replica.`);
@@ -470,9 +457,13 @@ var ReplicaRegistry = class {
   byRoot = /* @__PURE__ */ new Map();
   byProject = /* @__PURE__ */ new Map();
   projectOperations = /* @__PURE__ */ new Map();
+  clients = /* @__PURE__ */ new Set();
   get size() {
     return this.byId.size;
   }
+  registerClient(clientId) {
+    this.clients.add(clientId);
+  }
   async attach(clientId, params) {
     const root = await realpath(resolve2(params.directory));
     const settings = await readProjectSettings(root);
@@ -480,6 +471,9 @@ var ReplicaRegistry = class {
     return this.withProjectLock(projectKey, () => this.attachResolved(clientId, params, root, settings, projectKey));
   }
   async attachResolved(clientId, params, root, settings, projectKey) {
+    if (!this.clients.has(clientId)) {
+      throw new Error("The replica client disconnected before attachment started.");
+    }
     const rootEntry = this.byRoot.get(root);
     if (rootEntry) {
       if (rootEntry.projectKey !== projectKey) {
@@ -515,6 +509,11 @@ var ReplicaRegistry = class {
           this.events.status(entry.owners, { replicaId: entry.id, status: entry.status });
         }
       });
+      if (!this.clients.has(clientId)) {
+        await running.stop();
+        this.events.empty();
+        throw new Error("The replica client disconnected before attachment completed.");
+      }
       entry = {
         id,
         root,
@@ -537,17 +536,24 @@ var ReplicaRegistry = class {
       throw error;
     }
   }
-  detach(clientId, replicaId) {
+  async detach(clientId, replicaId) {
     const entry = this.require(replicaId);
-    entry.owners.delete(clientId);
-    this.scheduleStopWhenDetached(entry);
+    await this.withProjectLock(entry.projectKey, async () => {
+      entry.owners.delete(clientId);
+      if (entry.owners.size === 0) {
+        await this.stop(entry);
+      }
+    });
   }
-  detachClient(clientId) {
-    for (const entry of this.byId.values()) {
-      if (entry.owners.delete(clientId)) {
-        this.scheduleStopWhenDetached(entry);
+  async detachClient(clientId) {
+    this.clients.delete(clientId);
+    const owned = [...this.byId.values()].filter((entry) => entry.owners.has(clientId));
+    await Promise.all(owned.map((entry) => this.withProjectLock(entry.projectKey, async () => {
+      entry.owners.delete(clientId);
+      if (entry.owners.size === 0) {
+        await this.stop(entry);
       }
-    }
+    })));
   }
   async resolveConflict(replicaId, path, winner) {
     const entry = this.require(replicaId);
@@ -577,26 +583,12 @@ var ReplicaRegistry = class {
     await Promise.all([...this.byId.values()].map((entry) => this.stop(entry)));
   }
   addOwner(entry, clientId) {
-    if (entry.stopTimer) {
-      clearTimeout(entry.stopTimer);
-      entry.stopTimer = void 0;
-    }
     entry.owners.add(clientId);
   }
-  scheduleStopWhenDetached(entry) {
-    if (entry.owners.size !== 0 || entry.stopTimer) {
-      return;
-    }
-    entry.stopTimer = setTimeout(() => void this.stop(entry), DETACHED_REPLICA_GRACE_MS);
-    entry.stopTimer.unref();
-  }
   async stop(entry) {
     if (!this.byId.delete(entry.id)) {
       return;
     }
-    if (entry.stopTimer) {
-      clearTimeout(entry.stopTimer);
-    }
     this.byRoot.delete(entry.root);
     this.byProject.delete(entry.projectKey);
     entry.status = { state: "stopping" };
@@ -656,17 +648,17 @@ var CLOSED_SOCKET_ERRORS = /* @__PURE__ */ new Set([
   "ERR_STREAM_WRITE_AFTER_END"
 ]);
 var LeafRelaySocketWriter = class extends SocketMessageWriter {
-  constructor(socket) {
-    super(socket);
-    this.socket = socket;
+  constructor(transportSocket) {
+    super(transportSocket);
+    this.transportSocket = transportSocket;
   }
-  socket;
+  transportSocket;
   async write(message) {
     try {
       await super.write(message);
     } catch (error) {
       const code = error.code;
-      if (this.socket.destroyed || this.socket.writableEnded || code && CLOSED_SOCKET_ERRORS.has(code)) {
+      if (this.transportSocket.destroyed || this.transportSocket.writableEnded || code && CLOSED_SOCKET_ERRORS.has(code)) {
         return;
       }
       throw error;
@@ -680,7 +672,7 @@ function createSocketRpcConnection(socket) {
 // ../daemon/src/server.ts
 var IDLE_EXIT_MS = 6e4;
 var REPLICA_ALREADY_ACTIVE = -32010;
-var daemonVersion = true ? "0.2.2" : "development";
+var daemonVersion = true ? "0.2.4" : "development";
 var LeafRelayDaemonServer = class {
   constructor(options = {}) {
     this.options = options;
@@ -775,7 +767,7 @@ var LeafRelayDaemonServer = class {
   accept(socket) {
     this.cancelIdleExit();
     const rpc = createSocketRpcConnection(socket);
-    const client = { socket, rpc, initialized: false };
+    const client = { leaseId: randomUUID2(), socket, rpc, initialized: false };
     this.clients.add(client);
     rpc.onRequest(RPC_METHOD.initialize, (params) => this.initialize(client, params));
     rpc.onRequest(RPC_METHOD.daemonStatus, () => this.authorized(client, () => this.status()));
@@ -785,7 +777,7 @@ var LeafRelayDaemonServer = class {
     }));
     rpc.onRequest(RPC_METHOD.replicaAttach, (params) => this.authorized(client, async () => {
       try {
-        return await this.replicas.attach(client.clientId, params);
+        return await this.replicas.attach(client.leaseId, params);
       } catch (error) {
         if (error instanceof ReplicaAlreadyActiveError) {
           throw new ResponseError(REPLICA_ALREADY_ACTIVE, error.message, {
@@ -798,8 +790,8 @@ var LeafRelayDaemonServer = class {
         throw error;
       }
     }));
-    rpc.onRequest(RPC_METHOD.replicaDetach, (params) => this.authorized(client, () => {
-      this.replicas.detach(client.clientId, params.replicaId);
+    rpc.onRequest(RPC_METHOD.replicaDetach, (params) => this.authorized(client, async () => {
+      await this.replicas.detach(client.leaseId, params.replicaId);
       return null;
     }));
     rpc.onRequest(RPC_METHOD.replicaResolveConflict, (params) => this.authorized(client, async () => {
@@ -829,16 +821,16 @@ var LeafRelayDaemonServer = class {
       const result = await this.network.callServer(params.server, params.operation, decodeRpcValue(params.args));
       return encodeRpcValue(result);
     }));
-    rpc.onRequest(RPC_METHOD.projectOpen, (params) => this.authorized(client, () => this.network.openProject(client.clientId, params.server, params.projectId)));
+    rpc.onRequest(RPC_METHOD.projectOpen, (params) => this.authorized(client, () => this.network.openProject(client.leaseId, params.server, params.projectId)));
     rpc.onRequest(RPC_METHOD.projectClose, (params) => this.authorized(client, () => {
-      this.network.closeProject(client.clientId, params.projectKey);
+      this.network.closeProject(client.leaseId, params.projectKey);
       return null;
     }));
     rpc.onRequest(RPC_METHOD.projectCall, (params) => this.authorized(client, async () => {
       const result = await this.network.callProject(params.projectKey, params.operation, decodeRpcValue(params.args));
       return encodeRpcValue(await result);
     }));
-    rpc.onClose(() => this.closeClient(client));
+    rpc.onClose(() => void this.closeClient(client));
     rpc.onError((error) => void this.log("error", `JSON-RPC connection error: ${String(error[0])}`));
     rpc.listen();
   }
@@ -854,6 +846,7 @@ var LeafRelayDaemonServer = class {
     }
     client.clientId = params.clientId;
     client.initialized = true;
+    this.replicas.registerClient(client.leaseId);
     void this.log("info", `${params.clientName} ${params.clientVersion} connected (${params.clientId}).`);
     return {
       daemonVersion,
@@ -868,21 +861,24 @@ var LeafRelayDaemonServer = class {
     }
     return operation();
   }
-  closeClient(client) {
+  async closeClient(client) {
     if (!this.clients.delete(client)) {
       return;
     }
     if (client.clientId) {
-      this.replicas.detachClient(client.clientId);
-    }
-    if (client.clientId) {
-      this.network.detachClient(client.clientId);
+      try {
+        await this.replicas.detachClient(client.leaseId);
+      } catch (error) {
+        await this.log("error", `Failed to stop replicas for a disconnected client: ${error instanceof Error ? error.message : String(error)}`);
+      } finally {
+        this.network.detachClient(client.leaseId);
+      }
     }
     this.scheduleIdleExit();
   }
   notifyOwners(owners, method, notification) {
     for (const client of this.clients) {
-      if (client.clientId && owners.has(client.clientId)) {
+      if (owners.has(client.leaseId)) {
         this.notifyClient(client, method, notification);
       }
     }