fraim-hub 2.0.209 → 2.0.210

package/dist/src/ai-hub/conversation-store-lock.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLockStale = isLockStale;
+exports.withBucketLock = withBucketLock;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const DEFAULT_TIMEOUT_MS = 5000;
+const DEFAULT_STALE_MS = 10000;
+// Synchronous sleep without a busy spin (the store's write path is synchronous).
+function sleepMs(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // ESRCH: no such process. EPERM: exists but not ours (still alive).
+        return error.code === 'EPERM';
+    }
+}
+// A lock is stale (safe to steal) if its file is unreadable/absent, its timestamp is older than
+// staleMs, or it names a dead pid on this same host.
+function isLockStale(lockPath, staleMs = DEFAULT_STALE_MS) {
+    let info;
+    try {
+        info = JSON.parse(fs_1.default.readFileSync(lockPath, 'utf8'));
+    }
+    catch {
+        return true;
+    }
+    if (typeof info.ts === 'number' && Date.now() - info.ts > staleMs)
+        return true;
+    if (typeof info.pid === 'number' && info.host === os_1.default.hostname() && !pidAlive(info.pid))
+        return true;
+    return false;
+}
+// Run fn while holding an exclusive lock on lockPath. Steals a stale lock; throws if a live lock
+// cannot be acquired within timeoutMs. Always releases the lock, even if fn throws.
+function withBucketLock(lockPath, fn, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const staleMs = opts.staleMs ?? DEFAULT_STALE_MS;
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        let fd;
+        try {
+            fd = fs_1.default.openSync(lockPath, 'wx'); // O_CREAT | O_EXCL: fails if the lock already exists
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            if (isLockStale(lockPath, staleMs)) {
+                try {
+                    fs_1.default.unlinkSync(lockPath);
+                }
+                catch { /* another waiter won the steal; retry */ }
+                continue;
+            }
+            if (Date.now() > deadline) {
+                throw new Error(`conversation-store: timed out acquiring lock ${lockPath} after ${timeoutMs}ms`);
+            }
+            sleepMs(15);
+            continue;
+        }
+        try {
+            fs_1.default.writeSync(fd, JSON.stringify({ pid: process.pid, host: os_1.default.hostname(), ts: Date.now() }));
+        }
+        catch { /* the lock file content is advisory only */ }
+        try {
+            return fn();
+        }
+        finally {
+            try {
+                fs_1.default.closeSync(fd);
+            }
+            catch { /* already closed */ }
+            try {
+                fs_1.default.unlinkSync(lockPath);
+            }
+            catch { /* already stolen/removed */ }
+        }
+    }
+}