leafrelay 0.1.6 → 0.2.0

package/dist/daemon.js

@@ -0,0 +1,959 @@
+import {
+  ExtendedBaseAPI,
+  HttpRequestScheduler,
+  RemoteProject,
+  SocketIOAPI,
+  getServerSession,
+  normalizeServerUrl,
+  readConfig,
+  readProjectSettings,
+  removeKnownServer,
+  removeServerSession,
+  saveKnownServer,
+  saveServerSession,
+  serverKey,
+  startServe
+} from "./chunk-PRWBFOB2.js";
+
+// ../daemon/src/server.ts
+import { randomBytes } from "crypto";
+import { appendFile, chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
+import { createServer } from "net";
+
+// ../protocol/dist/index.js
+var LEAFRELAY_PROTOCOL_VERSION = 1;
+var RPC_METHOD = {
+  initialize: "leafrelay/initialize",
+  daemonStatus: "leafrelay/daemon/status",
+  daemonShutdown: "leafrelay/daemon/shutdown",
+  replicaAttach: "leafrelay/replica/attach",
+  replicaDetach: "leafrelay/replica/detach",
+  replicaResolveConflict: "leafrelay/replica/resolveConflict",
+  replicaRetry: "leafrelay/replica/retry",
+  sessionImport: "leafrelay/session/import",
+  sessionLogin: "leafrelay/session/login",
+  sessionLogout: "leafrelay/session/logout",
+  serverList: "leafrelay/server/list",
+  serverAdd: "leafrelay/server/add",
+  serverRemove: "leafrelay/server/remove",
+  serverCall: "leafrelay/server/call",
+  projectOpen: "leafrelay/project/open",
+  projectClose: "leafrelay/project/close",
+  projectCall: "leafrelay/project/call"
+};
+var RPC_NOTIFICATION = {
+  log: "leafrelay/log",
+  replicaStatus: "leafrelay/replica/status",
+  replicaConflict: "leafrelay/replica/conflict",
+  projectEvent: "leafrelay/project/event"
+};
+
+// ../daemon/src/server.ts
+import { ResponseError } from "vscode-jsonrpc/node";
+
+// ../daemon/src/paths.ts
+import { createHash } from "crypto";
+import { homedir } from "os";
+import { join, resolve } from "path";
+function daemonPaths(environment = process.env) {
+  const home = environment.LEAFRELAY_HOME ? resolve(environment.LEAFRELAY_HOME) : join(homedir(), ".leafrelay");
+  const socketPath = process.platform === "win32" ? `\\\\.\\pipe\\leafrelay-${createHash("sha256").update(home).digest("hex").slice(0, 16)}` : join(home, "daemon.sock");
+  return {
+    home,
+    socketPath,
+    metadataPath: join(home, "daemon.json"),
+    logPath: join(home, "daemon.log"),
+    startupLockPath: join(home, "daemon.starting")
+  };
+}
+
+// ../daemon/src/codec.ts
+function isEncodedBinary(value) {
+  return typeof value === "object" && value !== null && value.$leafrelay === "bytes" && typeof value.base64 === "string";
+}
+function encodeRpcValue(value) {
+  if (value instanceof Uint8Array) {
+    return { $leafrelay: "bytes", base64: Buffer.from(value).toString("base64") };
+  }
+  if (Array.isArray(value)) {
+    return value.map(encodeRpcValue);
+  }
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, encodeRpcValue(child)]));
+  }
+  return value;
+}
+function decodeRpcValue(value) {
+  if (isEncodedBinary(value)) {
+    return Uint8Array.from(Buffer.from(value.base64, "base64"));
+  }
+  if (Array.isArray(value)) {
+    return value.map(decodeRpcValue);
+  }
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, decodeRpcValue(child)]));
+  }
+  return value;
+}
+
+// ../daemon/src/networkRuntime.ts
+var PROJECT_IDLE_MS = 6e4;
+var SERVER_OPERATIONS = /* @__PURE__ */ new Set([
+  "userProjectsJson",
+  "getProjectsJson",
+  "projectEntitiesJson",
+  "newProject",
+  "cloneProject",
+  "renameProject",
+  "deleteProject",
+  "archiveProject",
+  "unarchiveProject",
+  "trashProject",
+  "untrashProject",
+  "getFile",
+  "addDoc",
+  "uploadFile",
+  "uploadProject",
+  "addFolder",
+  "deleteEntity",
+  "deleteAuxFiles",
+  "renameEntity",
+  "moveEntity",
+  "compile",
+  "stopCompile",
+  "indexAll",
+  "getMetadata",
+  "proxyRequestToSpellingApi",
+  "spellingControllerLearn",
+  "spellingControllerUnlearn",
+  "getProjectSettings",
+  "updateProjectSettings",
+  "getFileFromClsi",
+  "proxySyncPdf",
+  "proxySyncCode",
+  "getAllTags",
+  "createTag",
+  "renameTag",
+  "deleteTag",
+  "addProjectToTag",
+  "removeProjectFromTag",
+  "proxyToHistoryApiAndGetUpdates",
+  "proxyToHistoryApiAndGetFileDiff",
+  "proxyToHistoryApiAndGetFileTreeDiff",
+  "downloadZipOfVersion",
+  "getLabels",
+  "createLabel",
+  "deleteLabel",
+  "getMessages",
+  "sendMessage",
+  "refreshLinkedFile",
+  "createLinkedFile"
+]);
+var PROJECT_OPERATIONS = /* @__PURE__ */ new Set([
+  "init",
+  "joinProject",
+  "joinDoc",
+  "leaveDoc",
+  "applyOtUpdate",
+  "getConnectedUsers",
+  "updatePosition",
+  "syncFileChanges"
+]);
+var REMOTE_PROJECT_OPERATIONS = /* @__PURE__ */ new Set([
+  "entry",
+  "listEntries",
+  "read",
+  "write",
+  "mkdir",
+  "remove",
+  "getCurrentVersion",
+  "getFileTreeDiff"
+]);
+var NetworkRuntimeRegistry = class {
+  constructor(events) {
+    this.events = events;
+  }
+  events;
+  servers = /* @__PURE__ */ new Map();
+  projects = /* @__PURE__ */ new Map();
+  get projectCount() {
+    return this.projects.size;
+  }
+  async listServers() {
+    const config = await readConfig();
+    const keys = /* @__PURE__ */ new Set([...Object.keys(config.knownServers ?? {}), ...Object.keys(config.servers)]);
+    if (keys.size === 0) {
+      keys.add("www.overleaf.com");
+    }
+    return [...keys].sort().map((key) => {
+      const session = config.servers[key];
+      const known = config.knownServers?.[key];
+      return {
+        name: known?.name ?? key,
+        url: known?.url ?? session?.url ?? normalizeServerUrl(key),
+        loggedIn: Boolean(session),
+        userId: session?.userId,
+        userEmail: session?.userEmail
+      };
+    });
+  }
+  async addServer(name, url) {
+    await saveKnownServer(name, url);
+  }
+  async removeServer(server2) {
+    const key = serverKey(server2);
+    for (const project of this.projects.values()) {
+      if (project.server.key === key) {
+        await this.stopProject(project);
+      }
+    }
+    this.servers.delete(key);
+    await removeKnownServer(server2);
+  }
+  async login(params) {
+    const url = normalizeServerUrl(params.server);
+    const scheduler = new HttpRequestScheduler({
+      onRateLimit: (until) => this.events.log("warn", `${serverKey(url)} is rate limited until ${new Date(until).toISOString()}.`)
+    });
+    const api = new ExtendedBaseAPI(url, scheduler);
+    const response = params.cookie ? await api.cookiesLogin(params.cookie) : await api.passportLogin(params.email ?? "", params.password ?? "");
+    if (response.type !== "success" || !response.identity || !response.userInfo) {
+      throw new Error(response.message || `Login to ${url} failed.`);
+    }
+    const session = {
+      url,
+      userId: response.userInfo.userId,
+      userEmail: response.userInfo.userEmail || params.email || "",
+      identity: response.identity,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await saveServerSession(session);
+    this.servers.set(serverKey(url), { key: serverKey(url), session, scheduler, api });
+    return { userId: session.userId, userEmail: session.userEmail };
+  }
+  async importSession(params) {
+    const result = await this.login({ server: params.url, cookie: params.identity.cookies });
+    await saveKnownServer(params.name, params.url);
+    return result;
+  }
+  async logout(server2) {
+    const runtime = await this.requireServer(server2);
+    await runtime.api.logout(runtime.session.identity);
+    await removeServerSession(server2);
+    this.servers.delete(runtime.key);
+  }
+  async callServer(server2, operation, args) {
+    if (!SERVER_OPERATIONS.has(operation)) {
+      throw new Error(`Unsupported server operation: ${operation}.`);
+    }
+    const runtime = await this.requireServer(server2);
+    const method = runtime.api[operation];
+    if (typeof method !== "function") {
+      throw new Error(`Server operation ${operation} is unavailable.`);
+    }
+    return method.call(runtime.api, runtime.session.identity, ...args);
+  }
+  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 };
+  }
+  closeProject(clientId, projectKey) {
+    const runtime = this.requireProject(projectKey);
+    runtime.owners.delete(clientId);
+    this.scheduleProjectStop(runtime);
+  }
+  async callProject(projectKey, operation, args) {
+    const runtime = this.requireProject(projectKey);
+    await runtime.ready;
+    if (operation.startsWith("remote.")) {
+      const remoteOperation = operation.slice("remote.".length);
+      if (!REMOTE_PROJECT_OPERATIONS.has(remoteOperation)) {
+        throw new Error(`Unsupported remote project operation: ${remoteOperation}.`);
+      }
+      const method2 = runtime.remote[remoteOperation];
+      if (typeof method2 !== "function") {
+        throw new Error(`Remote project operation ${remoteOperation} is unavailable.`);
+      }
+      return this.enqueueProjectOperation(runtime, () => method2.apply(runtime.remote, args));
+    }
+    if (!PROJECT_OPERATIONS.has(operation)) {
+      throw new Error(`Unsupported project operation: ${operation}.`);
+    }
+    const method = runtime.socket[operation];
+    if (typeof method !== "function") {
+      throw new Error(`Project operation ${operation} is unavailable.`);
+    }
+    return method.apply(runtime.socket, args);
+  }
+  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;
+    return {
+      remote: this.replicaRemote(runtime),
+      release: () => {
+        if (released) {
+          return;
+        }
+        released = true;
+        runtime.replicaReferences -= 1;
+        this.scheduleProjectStop(runtime);
+      }
+    };
+  }
+  detachClient(clientId) {
+    for (const runtime of this.projects.values()) {
+      if (runtime.owners.delete(clientId)) {
+        this.scheduleProjectStop(runtime);
+      }
+    }
+  }
+  async stopAll() {
+    await Promise.all([...this.projects.values()].map((runtime) => this.stopProject(runtime)));
+    this.servers.clear();
+  }
+  async requireServer(server2) {
+    const key = serverKey(server2);
+    const existing = this.servers.get(key);
+    if (existing) {
+      return existing;
+    }
+    const session = await getServerSession(server2);
+    if (!session) {
+      throw new Error(`Not logged in to ${key}.`);
+    }
+    const scheduler = new HttpRequestScheduler({
+      onRateLimit: (until) => this.events.log("warn", `${key} is rate limited until ${new Date(until).toISOString()}.`)
+    });
+    const runtime = { key, session, scheduler, api: new ExtendedBaseAPI(session.url, scheduler) };
+    this.servers.set(key, runtime);
+    return runtime;
+  }
+  async getOrCreateProject(server2, projectId) {
+    const serverRuntime = await this.requireServer(server2);
+    const key = `${serverRuntime.key}:${projectId}`;
+    const existing = this.projects.get(key);
+    if (existing) {
+      return existing;
+    }
+    const socket = new SocketIOAPI(serverRuntime.session.url, serverRuntime.api, serverRuntime.session.identity, projectId);
+    const remote = new RemoteProject(
+      serverRuntime.session.url,
+      projectId,
+      serverRuntime.session.identity.cookies,
+      { api: serverRuntime.api, identity: serverRuntime.session.identity, socket }
+    );
+    const runtime = {
+      key,
+      server: serverRuntime,
+      projectId,
+      socket,
+      remote,
+      ready: Promise.resolve(),
+      owners: /* @__PURE__ */ new Set(),
+      replicaReferences: 0,
+      operationQueue: Promise.resolve()
+    };
+    runtime.ready = remote.connect().then(() => this.registerProjectEvents(runtime)).catch((error) => {
+      this.projects.delete(key);
+      socket.disconnect();
+      throw error;
+    });
+    this.projects.set(key, runtime);
+    return runtime;
+  }
+  registerProjectEvents(runtime) {
+    const emit = (event, ...args) => this.events.projectEvent(runtime.owners, {
+      projectKey: runtime.key,
+      event,
+      args
+    });
+    runtime.socket.updateEventHandlers({
+      onFileCreated: (...args) => emit("onFileCreated", ...args),
+      onFileRenamed: (...args) => emit("onFileRenamed", ...args),
+      onFileRemoved: (...args) => emit("onFileRemoved", ...args),
+      onFileMoved: (...args) => emit("onFileMoved", ...args),
+      onFileChanged: (...args) => emit("onFileChanged", ...args),
+      onDisconnected: () => emit("onDisconnected"),
+      onConnectionAccepted: (...args) => emit("onConnectionAccepted", ...args),
+      onClientUpdated: (...args) => emit("onClientUpdated", ...args),
+      onClientDisconnected: (...args) => emit("onClientDisconnected", ...args),
+      onReceivedMessage: (...args) => emit("onReceivedMessage", ...args),
+      onSpellCheckLanguageUpdated: (...args) => emit("onSpellCheckLanguageUpdated", ...args),
+      onCompilerUpdated: (...args) => emit("onCompilerUpdated", ...args),
+      onRootDocUpdated: (...args) => emit("onRootDocUpdated", ...args)
+    });
+  }
+  requireProject(projectKey) {
+    const runtime = this.projects.get(projectKey);
+    if (!runtime) {
+      throw new Error(`Unknown project runtime ${projectKey}.`);
+    }
+    return runtime;
+  }
+  replicaRemote(runtime) {
+    return {
+      connect: async () => {
+      },
+      disconnect: () => {
+      },
+      listEntries: () => runtime.remote.listEntries(),
+      entry: (path) => runtime.remote.entry(path),
+      read: (path) => this.enqueueProjectOperation(runtime, () => runtime.remote.read(path)),
+      write: (path, content) => this.enqueueProjectOperation(runtime, () => runtime.remote.write(path, content)),
+      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)
+    };
+  }
+  enqueueProjectOperation(runtime, operation) {
+    const result = runtime.operationQueue.then(operation);
+    runtime.operationQueue = result.then(() => void 0, () => void 0);
+    return result;
+  }
+  scheduleProjectStop(runtime) {
+    if (runtime.owners.size !== 0 || runtime.replicaReferences !== 0 || runtime.idleTimer) {
+      return;
+    }
+    runtime.idleTimer = setTimeout(() => void this.stopProject(runtime), PROJECT_IDLE_MS);
+    runtime.idleTimer.unref();
+  }
+  async stopProject(runtime) {
+    if (!this.projects.delete(runtime.key)) {
+      return;
+    }
+    if (runtime.idleTimer) {
+      clearTimeout(runtime.idleTimer);
+    }
+    runtime.socket.disconnect();
+  }
+};
+
+// ../daemon/src/replicaRegistry.ts
+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.`);
+    this.projectId = projectId;
+    this.activeRoot = activeRoot;
+    this.requestedRoot = requestedRoot;
+  }
+  projectId;
+  activeRoot;
+  requestedRoot;
+  code = "ReplicaAlreadyActive";
+};
+var ReplicaRegistry = class {
+  constructor(events, start = startServe) {
+    this.events = events;
+    this.start = start;
+  }
+  events;
+  start;
+  byId = /* @__PURE__ */ new Map();
+  byRoot = /* @__PURE__ */ new Map();
+  byProject = /* @__PURE__ */ new Map();
+  projectOperations = /* @__PURE__ */ new Map();
+  get size() {
+    return this.byId.size;
+  }
+  async attach(clientId, params) {
+    const root = await realpath(resolve2(params.directory));
+    const settings = await readProjectSettings(root);
+    const projectKey = `${settings.serverName}\0${settings.projectId}`;
+    return this.withProjectLock(projectKey, () => this.attachResolved(clientId, params, root, settings, projectKey));
+  }
+  async attachResolved(clientId, params, root, settings, projectKey) {
+    const rootEntry = this.byRoot.get(root);
+    if (rootEntry) {
+      if (rootEntry.projectKey !== projectKey) {
+        throw new Error(`${root} is already registered for another Overleaf project.`);
+      }
+      this.addOwner(rootEntry, clientId);
+      return this.result(rootEntry, true);
+    }
+    const projectEntry = this.byProject.get(projectKey);
+    if (projectEntry) {
+      throw new ReplicaAlreadyActiveError(settings.projectId, projectEntry.root, root);
+    }
+    const id = randomUUID();
+    const owners = /* @__PURE__ */ new Set([clientId]);
+    const status = { state: "starting" };
+    let entry;
+    this.events.status(owners, { replicaId: id, status });
+    try {
+      const running = await this.start(root, {
+        cookie: params.cookie,
+        log: (message) => this.events.log(`[${settings.projectName}] ${message}`),
+        onConflict: (path, reason) => {
+          if (!entry) {
+            return;
+          }
+          entry.status = { state: "paused", message: `Conflict in ${path}` };
+          this.events.conflict(entry.owners, {
+            replicaId: entry.id,
+            path,
+            reason,
+            conflicts: entry.running.conflicts()
+          });
+          this.events.status(entry.owners, { replicaId: entry.id, status: entry.status });
+        }
+      });
+      entry = {
+        id,
+        root,
+        projectKey,
+        serverName: settings.serverName,
+        projectId: settings.projectId,
+        projectName: settings.projectName,
+        owners,
+        running,
+        status: running.conflicts().length === 0 ? { state: "active" } : { state: "paused" }
+      };
+      this.byId.set(id, entry);
+      this.byRoot.set(root, entry);
+      this.byProject.set(projectKey, entry);
+      this.events.status(owners, { replicaId: id, status: entry.status });
+      return this.result(entry, false);
+    } catch (error) {
+      const failed = { state: "error", message: error instanceof Error ? error.message : String(error) };
+      this.events.status(owners, { replicaId: id, status: failed });
+      throw error;
+    }
+  }
+  detach(clientId, replicaId) {
+    const entry = this.require(replicaId);
+    entry.owners.delete(clientId);
+    this.scheduleStopWhenDetached(entry);
+  }
+  detachClient(clientId) {
+    for (const entry of this.byId.values()) {
+      if (entry.owners.delete(clientId)) {
+        this.scheduleStopWhenDetached(entry);
+      }
+    }
+  }
+  async resolveConflict(replicaId, path, winner) {
+    const entry = this.require(replicaId);
+    await entry.running.resolveConflict(path, winner);
+    entry.status = entry.running.conflicts().length === 0 ? { state: "active" } : { state: "paused" };
+    this.events.status(entry.owners, { replicaId, status: entry.status });
+  }
+  async retry(replicaId, path) {
+    const entry = this.require(replicaId);
+    await entry.running.retry(path);
+    entry.status = entry.running.conflicts().length === 0 ? { state: "active" } : { state: "paused" };
+    this.events.status(entry.owners, { replicaId, status: entry.status });
+  }
+  list() {
+    return [...this.byId.values()].map((entry) => ({
+      id: entry.id,
+      root: entry.root,
+      serverName: entry.serverName,
+      projectId: entry.projectId,
+      projectName: entry.projectName,
+      clients: entry.owners.size,
+      status: entry.status,
+      conflicts: entry.running.conflicts()
+    }));
+  }
+  async stopAll() {
+    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" };
+    this.events.status(entry.owners, { replicaId: entry.id, status: entry.status });
+    await entry.running.stop();
+    this.events.empty();
+  }
+  require(replicaId) {
+    const entry = this.byId.get(replicaId);
+    if (!entry) {
+      throw new Error(`Unknown replica ${replicaId}.`);
+    }
+    return entry;
+  }
+  result(entry, shared) {
+    return {
+      replicaId: entry.id,
+      root: entry.root,
+      serverName: entry.serverName,
+      projectId: entry.projectId,
+      projectName: entry.projectName,
+      shared,
+      status: entry.status,
+      conflicts: entry.running.conflicts()
+    };
+  }
+  async withProjectLock(projectKey, operation) {
+    const previous = this.projectOperations.get(projectKey) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolveOperation) => {
+      release = resolveOperation;
+    });
+    this.projectOperations.set(projectKey, current);
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release();
+      if (this.projectOperations.get(projectKey) === current) {
+        this.projectOperations.delete(projectKey);
+      }
+    }
+  }
+};
+
+// ../daemon/src/transport.ts
+import {
+  createMessageConnection,
+  SocketMessageReader,
+  SocketMessageWriter
+} from "vscode-jsonrpc/node";
+var CLOSED_SOCKET_ERRORS = /* @__PURE__ */ new Set([
+  "EPIPE",
+  "ECONNRESET",
+  "ERR_SOCKET_CLOSED",
+  "ERR_STREAM_DESTROYED",
+  "ERR_STREAM_WRITE_AFTER_END"
+]);
+var LeafRelaySocketWriter = class extends SocketMessageWriter {
+  constructor(socket) {
+    super(socket);
+    this.socket = socket;
+  }
+  socket;
+  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)) {
+        return;
+      }
+      throw error;
+    }
+  }
+};
+function createSocketRpcConnection(socket) {
+  return createMessageConnection(new SocketMessageReader(socket), new LeafRelaySocketWriter(socket));
+}
+
+// ../daemon/src/server.ts
+var IDLE_EXIT_MS = 6e4;
+var REPLICA_ALREADY_ACTIVE = -32010;
+var daemonVersion = true ? "0.2.0" : "development";
+var LeafRelayDaemonServer = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.paths = options.paths ?? daemonPaths();
+    this.token = options.token ?? randomBytes(32).toString("hex");
+    this.network = new NetworkRuntimeRegistry({
+      projectEvent: (owners, notification) => this.notifyOwners(owners, RPC_NOTIFICATION.projectEvent, notification),
+      log: (level, message) => void this.log(level, message)
+    });
+    this.replicas = new ReplicaRegistry({
+      status: (owners, notification) => this.notifyOwners(owners, RPC_NOTIFICATION.replicaStatus, notification),
+      conflict: (owners, notification) => this.notifyOwners(owners, RPC_NOTIFICATION.replicaConflict, notification),
+      empty: () => this.scheduleIdleExit(),
+      log: (message) => void this.log("info", message)
+    }, async (directory, startOptions) => {
+      const settings = await readProjectSettings(directory);
+      const lease = await this.network.acquireReplica(settings.serverName, settings.projectId);
+      try {
+        const running = await startServe(directory, { ...startOptions, remote: lease.remote });
+        return {
+          ...running,
+          stop: async () => {
+            await running.stop();
+            lease.release();
+          }
+        };
+      } catch (error) {
+        lease.release();
+        throw error;
+      }
+    });
+  }
+  options;
+  paths;
+  token;
+  startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  clients = /* @__PURE__ */ new Set();
+  network;
+  replicas;
+  server;
+  idleTimer;
+  stopping;
+  async start() {
+    await mkdir(this.paths.home, { recursive: true, mode: 448 });
+    if (process.platform !== "win32") {
+      await rm(this.paths.socketPath, { force: true });
+    }
+    this.server = createServer((socket) => this.accept(socket));
+    await new Promise((resolveListen, reject) => {
+      this.server.once("error", reject);
+      this.server.listen(this.paths.socketPath, () => {
+        this.server.off("error", reject);
+        resolveListen();
+      });
+    });
+    if (process.platform !== "win32") {
+      await chmod(this.paths.socketPath, 384);
+    }
+    const metadata = {
+      pid: process.pid,
+      socketPath: this.paths.socketPath,
+      token: this.token,
+      protocolVersion: LEAFRELAY_PROTOCOL_VERSION,
+      version: daemonVersion,
+      startedAt: this.startedAt
+    };
+    await writeFile(this.paths.metadataPath, `${JSON.stringify(metadata, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+    await chmod(this.paths.metadataPath, 384);
+    await this.log("info", `Daemon ${daemonVersion} listening on ${this.paths.socketPath}.`);
+    this.scheduleIdleExit();
+    return metadata;
+  }
+  async stop() {
+    if (this.stopping) {
+      return this.stopping;
+    }
+    this.stopping = this.performStop();
+    return this.stopping;
+  }
+  status() {
+    return {
+      pid: process.pid,
+      version: daemonVersion,
+      protocolVersion: LEAFRELAY_PROTOCOL_VERSION,
+      startedAt: this.startedAt,
+      clients: this.clients.size,
+      projects: this.network.projectCount,
+      replicas: this.replicas.list()
+    };
+  }
+  accept(socket) {
+    this.cancelIdleExit();
+    const rpc = createSocketRpcConnection(socket);
+    const client = { 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()));
+    rpc.onRequest(RPC_METHOD.daemonShutdown, () => this.authorized(client, async () => {
+      setTimeout(() => void this.stop(), 25);
+      return null;
+    }));
+    rpc.onRequest(RPC_METHOD.replicaAttach, (params) => this.authorized(client, async () => {
+      try {
+        return await this.replicas.attach(client.clientId, params);
+      } catch (error) {
+        if (error instanceof ReplicaAlreadyActiveError) {
+          throw new ResponseError(REPLICA_ALREADY_ACTIVE, error.message, {
+            code: error.code,
+            projectId: error.projectId,
+            activeRoot: error.activeRoot,
+            requestedRoot: error.requestedRoot
+          });
+        }
+        throw error;
+      }
+    }));
+    rpc.onRequest(RPC_METHOD.replicaDetach, (params) => this.authorized(client, () => {
+      this.replicas.detach(client.clientId, params.replicaId);
+      return null;
+    }));
+    rpc.onRequest(RPC_METHOD.replicaResolveConflict, (params) => this.authorized(client, async () => {
+      await this.replicas.resolveConflict(params.replicaId, params.path, params.winner);
+      return null;
+    }));
+    rpc.onRequest(RPC_METHOD.replicaRetry, (params) => this.authorized(client, async () => {
+      await this.replicas.retry(params.replicaId, params.path);
+      return null;
+    }));
+    rpc.onRequest(RPC_METHOD.serverList, () => this.authorized(client, () => this.network.listServers()));
+    rpc.onRequest(RPC_METHOD.serverAdd, (params) => this.authorized(client, async () => {
+      await this.network.addServer(params.name, params.url);
+      return null;
+    }));
+    rpc.onRequest(RPC_METHOD.serverRemove, (params) => this.authorized(client, async () => {
+      await this.network.removeServer(params.server);
+      return null;
+    }));
+    rpc.onRequest(RPC_METHOD.sessionLogin, (params) => this.authorized(client, () => this.network.login(params)));
+    rpc.onRequest(RPC_METHOD.sessionImport, (params) => this.authorized(client, () => this.network.importSession(params)));
+    rpc.onRequest(RPC_METHOD.sessionLogout, (params) => this.authorized(client, async () => {
+      await this.network.logout(params.server);
+      return null;
+    }));
+    rpc.onRequest(RPC_METHOD.serverCall, (params) => this.authorized(client, async () => {
+      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.projectClose, (params) => this.authorized(client, () => {
+      this.network.closeProject(client.clientId, 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.onError((error) => void this.log("error", `JSON-RPC connection error: ${String(error[0])}`));
+    rpc.listen();
+  }
+  initialize(client, params) {
+    if (params.token !== this.token) {
+      throw new ResponseError(-32001, "Daemon authentication failed.");
+    }
+    if (params.protocolVersion !== LEAFRELAY_PROTOCOL_VERSION) {
+      throw new ResponseError(-32002, `Protocol ${params.protocolVersion} is incompatible with daemon protocol ${LEAFRELAY_PROTOCOL_VERSION}.`);
+    }
+    if (!params.clientId) {
+      throw new ResponseError(-32602, "clientId is required.");
+    }
+    client.clientId = params.clientId;
+    client.initialized = true;
+    void this.log("info", `${params.clientName} ${params.clientVersion} connected (${params.clientId}).`);
+    return {
+      daemonVersion,
+      protocolVersion: LEAFRELAY_PROTOCOL_VERSION,
+      pid: process.pid,
+      startedAt: this.startedAt
+    };
+  }
+  async authorized(client, operation) {
+    if (!client.initialized) {
+      throw new ResponseError(-32001, "Initialize the daemon connection first.");
+    }
+    return operation();
+  }
+  closeClient(client) {
+    if (!this.clients.delete(client)) {
+      return;
+    }
+    if (client.clientId) {
+      this.replicas.detachClient(client.clientId);
+    }
+    if (client.clientId) {
+      this.network.detachClient(client.clientId);
+    }
+    this.scheduleIdleExit();
+  }
+  notifyOwners(owners, method, notification) {
+    for (const client of this.clients) {
+      if (client.clientId && owners.has(client.clientId)) {
+        this.notifyClient(client, method, notification);
+      }
+    }
+  }
+  async log(level, message) {
+    const notification = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), level, message };
+    await appendFile(this.paths.logPath, `${notification.timestamp} [${level}] ${message}
+`, { encoding: "utf8", mode: 384 });
+    for (const client of this.clients) {
+      if (client.initialized) {
+        this.notifyClient(client, RPC_NOTIFICATION.log, notification);
+      }
+    }
+  }
+  notifyClient(client, method, notification) {
+    if (!this.clients.has(client) || client.socket.destroyed) {
+      return;
+    }
+    void client.rpc.sendNotification(method, notification).catch(() => this.closeClient(client));
+  }
+  scheduleIdleExit() {
+    if (this.options.exitOnIdle === false || this.clients.size !== 0 || this.replicas.size !== 0 || this.idleTimer) {
+      return;
+    }
+    this.idleTimer = setTimeout(() => void this.stop(), IDLE_EXIT_MS);
+    this.idleTimer.unref();
+  }
+  cancelIdleExit() {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = void 0;
+    }
+  }
+  async performStop() {
+    this.cancelIdleExit();
+    await this.replicas.stopAll();
+    await this.network.stopAll();
+    for (const client of this.clients) {
+      client.rpc.dispose();
+      client.socket.destroy();
+    }
+    this.clients.clear();
+    if (this.server) {
+      await new Promise((resolveClose) => this.server.close(() => resolveClose()));
+    }
+    await rm(this.paths.metadataPath, { force: true });
+    if (process.platform !== "win32") {
+      await rm(this.paths.socketPath, { force: true });
+    }
+  }
+};
+
+// ../daemon/src/main.ts
+var server = new LeafRelayDaemonServer();
+var stop = () => {
+  process.off("SIGINT", stop);
+  process.off("SIGTERM", stop);
+  void server.stop().finally(() => process.exit(0));
+};
+process.on("SIGINT", stop);
+process.on("SIGTERM", stop);
+process.on("uncaughtException", (error) => {
+  console.error(error);
+  void server.stop().finally(() => process.exit(1));
+});
+process.on("unhandledRejection", (error) => {
+  console.error(error);
+  void server.stop().finally(() => process.exit(1));
+});
+void server.start().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});
+//# sourceMappingURL=daemon.js.map