@n-seiji/nuthatch 0.1.5 → 0.2.0

package/dist/cli-wcnyhk4w.js

@@ -0,0 +1,124 @@
+import {
+  EXIT_SAFE_REJECTION,
+  fail
+} from "./cli-77yanq37.js";
+
+// src/infra/lock.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+// src/domain/lock-policy.ts
+var canReclaimLock = (input) => {
+  if (input.processAlive !== false) {
+    return false;
+  }
+  return input.nowMs - input.startedAtMs > input.ttlMs;
+};
+
+// src/infra/lock.ts
+var LOCK_DIR_NAME = "nuthatch-lock";
+var LOCK_INFO_FILE = "info.json";
+var DEFAULT_TTL_MS = 30000;
+var HEARTBEAT_INTERVAL_MS = 5000;
+
+class LockHeldError extends Error {
+  info;
+  constructor(info) {
+    super(`Repository is locked by another nuthatch process (pid ${info.pid})`);
+    this.name = "LockHeldError";
+    this.info = info;
+  }
+}
+var isProcessAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const { code } = error;
+    if (code === "ESRCH") {
+      return false;
+    }
+    if (code === "EPERM") {
+      return true;
+    }
+    return "unknown";
+  }
+};
+var readLockInfo = async (lockDir) => {
+  try {
+    const raw = await readFile(join(lockDir, LOCK_INFO_FILE), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var writeLockInfo = async (lockDir, info) => {
+  await writeFile(join(lockDir, LOCK_INFO_FILE), JSON.stringify(info), "utf8");
+};
+var acquireRepoLock = async (commonDir, ttlMs = DEFAULT_TTL_MS) => {
+  const lockDir = join(commonDir, LOCK_DIR_NAME);
+  for (;; ) {
+    try {
+      await mkdir(lockDir);
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw error;
+      }
+      const existing = await readLockInfo(lockDir);
+      if (existing === null) {
+        throw new LockHeldError({ pid: -1, startedAtMs: 0, token: "unknown" });
+      }
+      const reclaimable = canReclaimLock({
+        processAlive: isProcessAlive(existing.pid),
+        startedAtMs: existing.startedAtMs,
+        nowMs: Date.now(),
+        ttlMs
+      });
+      if (!reclaimable) {
+        throw new LockHeldError(existing);
+      }
+      await rm(lockDir, { recursive: true, force: true });
+    }
+  }
+  const info = {
+    pid: process.pid,
+    startedAtMs: Date.now(),
+    token: randomUUID()
+  };
+  await writeLockInfo(lockDir, info);
+  const heartbeat = setInterval(() => {
+    writeLockInfo(lockDir, { ...info, startedAtMs: Date.now() });
+  }, HEARTBEAT_INTERVAL_MS);
+  heartbeat.unref();
+  return {
+    async release() {
+      clearInterval(heartbeat);
+      await rm(lockDir, { recursive: true, force: true });
+    }
+  };
+};
+var acquireUnlessHeld = async (commonDir) => {
+  try {
+    return await acquireRepoLock(commonDir);
+  } catch (error) {
+    if (error instanceof LockHeldError) {
+      return error;
+    }
+    throw error;
+  }
+};
+var withRepoLock = async (commonDir, mutate) => {
+  const lock = await acquireUnlessHeld(commonDir);
+  if (lock instanceof LockHeldError) {
+    return fail(EXIT_SAFE_REJECTION, lock.message);
+  }
+  try {
+    return await mutate();
+  } finally {
+    await lock.release();
+  }
+};
+
+export { withRepoLock };