@routedock/routedock 0.3.0 → 0.4.0

package/dist/node.js

@@ -0,0 +1,159 @@
+import { randomBytes } from 'crypto';
+import fs from 'fs/promises';
+import path from 'path';
+
+// src/store/FileSpendStore.ts
+var DEFAULT_LOCK_STALE_MS = 1e4;
+var DEFAULT_LOCK_TIMEOUT_MS = 15e3;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var FileSpendStore = class {
+  filePath;
+  lockPath;
+  lockStaleMs;
+  lockTimeoutMs;
+  constructor(filePath, options = {}) {
+    this.filePath = filePath;
+    this.lockPath = `${filePath}.lock`;
+    this.lockStaleMs = options.lockStaleMs ?? DEFAULT_LOCK_STALE_MS;
+    this.lockTimeoutMs = options.lockTimeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS;
+  }
+  async read() {
+    let data;
+    try {
+      data = await fs.readFile(this.filePath, "utf-8");
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return null;
+      }
+      throw new Error(
+        `[FileSpendStore] Failed to read spend file at ${this.filePath}: ${err.message}`
+      );
+    }
+    try {
+      return JSON.parse(data);
+    } catch {
+      throw new Error(
+        `[FileSpendStore] Spend file at ${this.filePath} contains invalid JSON. Delete or repair it before resuming. Raw content: ${data.slice(0, 120)}`
+      );
+    }
+  }
+  async write(state) {
+    await this.withLock(async (assertHeld) => {
+      await this.writeFile(state, assertHeld);
+    });
+  }
+  /**
+   * Atomically read-modify-write the accumulator under the cross-process lock.
+   * `fn` receives the current state (or null) and returns the state to persist,
+   * or `undefined` to leave the file untouched. If `fn` throws, nothing is
+   * written and the lock is released.
+   */
+  async update(fn) {
+    return this.withLock(async (assertHeld) => {
+      const prev = await this.read();
+      const next = fn(prev);
+      if (next === void 0) return prev;
+      await this.writeFile(next, assertHeld);
+      return next;
+    });
+  }
+  // ── internals ──────────────────────────────────────────────────────────────
+  async writeFile(state, assertHeld) {
+    const tmpPath = `${this.filePath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+    try {
+      await fs.writeFile(tmpPath, JSON.stringify(state, null, 2), "utf-8");
+      await assertHeld();
+      await fs.rename(tmpPath, this.filePath);
+    } catch (err) {
+      await fs.rm(tmpPath, { force: true }).catch(() => {
+      });
+      throw err;
+    }
+  }
+  /** Run `fn` while holding the lock file; always releases it. */
+  async withLock(fn) {
+    await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+    const token = `${process.pid}:${randomBytes(8).toString("hex")}`;
+    await this.acquireLock(token);
+    const heartbeat = setInterval(() => {
+      const now = /* @__PURE__ */ new Date();
+      fs.utimes(this.lockPath, now, now).catch(() => {
+      });
+    }, Math.max(10, Math.floor(this.lockStaleMs / 3)));
+    heartbeat.unref();
+    const assertHeld = async () => {
+      let current;
+      try {
+        current = await fs.readFile(this.lockPath, "utf-8");
+      } catch {
+        current = "";
+      }
+      if (current !== token) {
+        throw new Error(
+          `[FileSpendStore] Lost the lock on ${this.lockPath} before committing; refusing to overwrite the spend file. Retry the operation.`
+        );
+      }
+    };
+    try {
+      return await fn(assertHeld);
+    } finally {
+      clearInterval(heartbeat);
+      await this.releaseLock(token);
+    }
+  }
+  async acquireLock(token) {
+    const deadline = Date.now() + this.lockTimeoutMs;
+    let delay = 5;
+    for (; ; ) {
+      try {
+        const handle = await fs.open(this.lockPath, "wx");
+        try {
+          await handle.writeFile(token, "utf-8");
+        } finally {
+          await handle.close();
+        }
+        return;
+      } catch (err) {
+        if (err.code !== "EEXIST") {
+          throw new Error(
+            `[FileSpendStore] Failed to create lock file ${this.lockPath}: ${err.message}`
+          );
+        }
+      }
+      await this.breakIfStale();
+      if (Date.now() >= deadline) {
+        throw new Error(
+          `[FileSpendStore] Timed out after ${this.lockTimeoutMs}ms waiting for ${this.lockPath}. Another process is holding the spend file lock; if none is running, delete the lock file.`
+        );
+      }
+      await sleep(delay + Math.floor(Math.random() * delay));
+      delay = Math.min(delay * 2, 50);
+    }
+  }
+  /** Remove the lock if its holder stopped refreshing it (crashed process). */
+  async breakIfStale() {
+    let before;
+    try {
+      before = await fs.stat(this.lockPath);
+    } catch {
+      return;
+    }
+    if (Date.now() - before.mtimeMs <= this.lockStaleMs) return;
+    try {
+      const after = await fs.stat(this.lockPath);
+      if (after.ino !== before.ino || after.mtimeMs !== before.mtimeMs) return;
+      await fs.unlink(this.lockPath);
+    } catch {
+    }
+  }
+  async releaseLock(token) {
+    try {
+      if (await fs.readFile(this.lockPath, "utf-8") === token) {
+        await fs.unlink(this.lockPath);
+      }
+    } catch {
+    }
+  }
+};
+
+export { FileSpendStore };