clinkx 0.3.0 → 1.1.0

package/dist/progress-report/lock.js

@@ -0,0 +1,343 @@
+import { randomBytes } from "node:crypto";
+import { open, readFile, stat, unlink, utimes } from "node:fs/promises";
+import { hostname } from "node:os";
+import { join } from "node:path";
+import { ExecutionError } from "../errors.js";
+import { logger } from "../logger.js";
+export const LOCK_FILENAME = ".lock";
+/** Give up rather than block an MCP request forever on a contended session. */
+export const LOCK_ACQUIRE_TIMEOUT_MS = 10_000;
+/**
+ * How often a holder refreshes its own lock's mtime. This is what makes a lock
+ * observably ALIVE to a reader that cannot probe our PID, and it is also what
+ * lets a stolen-from holder notice and abort. Matches the interval the workflow
+ * `run.lock` and the dashboard credential store already use.
+ */
+export const LOCK_HEARTBEAT_MS = 10_000;
+/**
+ * Floor for the foreign-host staleness window. A lock is only judged abandoned
+ * on heartbeat evidence once it has missed several beats AND at least this long
+ * has passed, so ordinary scheduling jitter never looks like death.
+ */
+export const LOCK_HEARTBEAT_STALE_FLOOR_MS = 60_000;
+/** An mtime this far in the future means clock skew, not liveness evidence. */
+const LOCK_FUTURE_MTIME_TOLERANCE_MS = 60_000;
+const RETRY_BASE_MS = 15;
+const RETRY_JITTER_MS = 20;
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+async function readLockBody(lockPath) {
+    try {
+        const raw = await readFile(lockPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null)
+            return null;
+        const record = parsed;
+        const token = record["token"];
+        const pid = record["pid"];
+        const host = record["hostname"];
+        if (typeof token !== "string" || token === "")
+            return null;
+        const interval = record["heartbeat_interval_ms"];
+        return {
+            token,
+            pid: typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? pid : 0,
+            hostname: typeof host === "string" ? host : "",
+            acquired_at: typeof record["acquired_at"] === "string" ? record["acquired_at"] : "",
+            heartbeat_interval_ms: typeof interval === "number" && Number.isFinite(interval) && interval > 0 ? interval : 0,
+        };
+    }
+    catch {
+        // Absent, unreadable, or unparseable: never provably ours, never provably dead.
+        return null;
+    }
+}
+async function readLockToken(lockPath) {
+    return (await readLockBody(lockPath))?.token ?? null;
+}
+/** Serializes the one destructive step in this module. See `reclaimAbandonedLock`. */
+const STEAL_LOCK_SUFFIX = ".steal";
+function stealPathFor(lockPath) {
+    return `${lockPath}${STEAL_LOCK_SUFFIX}`;
+}
+/**
+ * Delete an abandoned lock, but only ever one contender at a time.
+ *
+ * Reclamation is the one destructive step here, so it gets its own `O_EXCL`
+ * file. Without it two contenders can both observe the SAME dead lock and both
+ * authorize an unlink; the first unlinks, recreates and enters, and the second's
+ * already-authorized unlink then lands on the winner's LIVE lock and lets it
+ * enter too. Both would read the same revision, both pass the CAS, and one
+ * update would be silently lost. Re-reading the token narrows that window but
+ * cannot close it, because the winner's unlink+create can land between the
+ * loser's read and its unlink. Holding the steal lock across the re-read makes
+ * the check-and-delete indivisible with respect to other reclaimers.
+ *
+ * Reports the REAL outcome, which is also the caller's "progress was made"
+ * signal. Reporting success on an unlink that did not happen would be worse
+ * than useless: the caller skips its backoff and immediately re-observes the
+ * same undeletable lock, so a lock that is readable but cannot be removed spins
+ * for the whole deadline at full CPU, emitting one untruthful "reclaiming"
+ * warn per iteration into the MCP client's captured stderr.
+ */
+async function reclaimAbandonedLock(lockPath, observedToken) {
+    const stealPath = stealPathFor(lockPath);
+    let handle;
+    try {
+        handle = await open(stealPath, "wx", 0o600);
+    }
+    catch (err) {
+        // Another contender is already reclaiming (or the steal lock is stranded);
+        // either way this contender waits rather than racing it. The errno is
+        // carried out because EEXIST (a real contender) and EACCES/EROFS/ENOSPC/
+        // ENOENT (the steal lock was never created at all) need different operator
+        // advice, and only the former makes "remove that file" sound guidance.
+        return {
+            kind: "steal_lock_unavailable",
+            code: err.code ?? "unknown",
+        };
+    }
+    try {
+        // Re-read UNDER the steal lock: if the winner already replaced the dead
+        // lock, the token no longer matches and we must not touch it.
+        if ((await readLockToken(lockPath)) !== observedToken)
+            return { kind: "superseded" };
+        try {
+            await unlink(lockPath);
+            return { kind: "reclaimed" };
+        }
+        catch (err) {
+            // ENOENT means somebody else already removed it, which IS progress.
+            // Anything else (an immutable flag, EPERM, a read-only mount) is a
+            // failure and must not be dressed up as a reclamation.
+            const code = err.code;
+            return code === "ENOENT" ? { kind: "reclaimed" } : { kind: "unlink_failed", code: code ?? "unknown" };
+        }
+    }
+    finally {
+        // A close() that rejects (EIO, ENOSPC) must not skip the unlink: stranding
+        // our OWN steal lock would trigger by accident the exact residual this
+        // design documents as its worst failure mode, and would escape
+        // `withSessionLock` as a raw unwrapped errno.
+        await handle.close().catch(() => undefined);
+        await unlink(stealPath).catch((err) => {
+            // Stranding this file disables automatic reclamation for the session until
+            // an operator removes it. That residual is documented, but swallowing it
+            // silently means it only ever surfaces to a LATER contender's timeout.
+            logger.warn({ stealPath, err: err.message }, "progress-report: could not remove the reclaim lock; automatic reclamation is disabled for this session until it is deleted");
+        });
+    }
+}
+/** Alive unless the OS positively says the process is gone. */
+function sameHostProcessIsDead(pid) {
+    if (pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return false;
+    }
+    catch (err) {
+        // EPERM means it exists and belongs to someone else — alive, not dead.
+        return err.code === "ESRCH";
+    }
+}
+/**
+ * Decide whether the lock on disk may be reclaimed. Reclamation requires
+ * POSITIVE EVIDENCE OF DEATH; every ambiguity resolves to "unknown", which
+ * waits. A bare mtime age is never sufficient on its own.
+ */
+async function observeLock(lockPath) {
+    const body = await readLockBody(lockPath);
+    if (body === null) {
+        return { kind: "unknown", why: "lock body is absent, unreadable, or malformed" };
+    }
+    // Same host: the PID probe is the strongest possible evidence, so it wins
+    // outright and no heartbeat is consulted.
+    if (body.hostname !== "" && body.hostname === hostname()) {
+        return sameHostProcessIsDead(body.pid)
+            ? { kind: "abandoned", token: body.token, why: `owner pid ${String(body.pid)} is gone` }
+            : { kind: "live" };
+    }
+    // Foreign host (or an unrecorded one): we cannot probe the process, so the
+    // only admissible evidence is a heartbeat the holder promised to send.
+    if (body.heartbeat_interval_ms <= 0) {
+        return { kind: "unknown", why: "holder declared no heartbeat, so silence proves nothing" };
+    }
+    const stats = await stat(lockPath).catch(() => null);
+    if (stats === null) {
+        return { kind: "unknown", why: "lock vanished while being observed" };
+    }
+    const ageMs = Date.now() - stats.mtimeMs;
+    if (ageMs < -LOCK_FUTURE_MTIME_TOLERANCE_MS) {
+        return { kind: "unknown", why: "lock mtime is in the future; clocks disagree" };
+    }
+    const staleAfterMs = Math.max(LOCK_HEARTBEAT_STALE_FLOOR_MS, body.heartbeat_interval_ms * 6);
+    return ageMs > staleAfterMs
+        ? {
+            kind: "abandoned",
+            token: body.token,
+            why: `no heartbeat for ${String(Math.round(ageMs))}ms (stale after ${String(staleAfterMs)}ms)`,
+        }
+        : { kind: "live" };
+}
+/**
+ * Run `fn` while holding an exclusive cross-process lock on `sessionDir`.
+ *
+ * THE EXCLUSION PRIMITIVE. `open(path, "wx")` is `O_CREAT | O_EXCL`, which the
+ * kernel guarantees is atomic against every other creator on the same
+ * filesystem — including a second ClinkX server process, which is the real case
+ * here (a `clinkx` and a `clinkx-test` server are routinely connected at once).
+ * A revision compare-and-swap alone is NOT a substitute: read -> compare ->
+ * replace has a window between the compare and the rename, so the CAS detects a
+ * lost update while this is what prevents one.
+ *
+ * RECLAMATION REQUIRES PROOF, NOT AGE. `O_EXCL` arbitrates creation only, so an
+ * unconditional unlink of a lock merely judged old is unsafe: two contenders can
+ * both judge the same abandoned lock, the first can unlink-recreate-and-enter,
+ * and the second's already-justified unlink then deletes the FIRST's live lock
+ * and lets it enter too. Both would then read the same revision, both pass the
+ * CAS, and one write would be silently lost. So a lock is reclaimed only on
+ * positive evidence of death: a dead PID on this host, or — for a lock written
+ * on another host, where no probe is possible — a heartbeat that has been
+ * missing for several declared intervals. Every other case waits. A holder that
+ * declared no heartbeat is never reclaimed on silence, which is what keeps a
+ * lock written by an older producer safe. Evidence alone is still not enough to
+ * make two simultaneous reclaimers safe, so the unlink itself is serialized
+ * behind a second `O_EXCL` file (`reclaimAbandonedLock`).
+ *
+ * Release is ownership-checked: the holder re-reads the lock body and unlinks
+ * only if the token is still its own, so a holder that was stolen from does not
+ * normally delete the new owner's lock. Node exposes no atomic
+ * compare-and-unlink, so that check is read-then-unlink and a steal landing
+ * inside that window is still possible; the guarantee is "will not", not
+ * "cannot".
+ *
+ * Honest residuals, all accepted under a single-user local-filesystem model:
+ * `O_EXCL` is not reliable on some network filesystems (NFSv2/v3); a PID can be
+ * recycled, so a probe can report a live process that is not the original
+ * holder; and a holder suspended (SIGSTOP, a paused container) stops beating and
+ * looks abandoned to a foreign-host reader. These are the same class of residual
+ * the repo already accepts for `run.lock` and `contained-file.ts`. The steal
+ * lock adds one of its own: a process that dies while holding `.lock.steal`
+ * leaves it behind, which disables AUTOMATIC RECLAMATION for that session —
+ * normal acquisition and release are unaffected — until an operator removes the
+ * file. That is strictly the better failure mode: a session that needs a manual
+ * unwedge, rather than two writers in the critical section.
+ */
+export async function withSessionLock(sessionDir, fn, options = {}) {
+    const lockPath = join(sessionDir, LOCK_FILENAME);
+    const token = randomBytes(16).toString("hex");
+    const acquireTimeoutMs = options.acquireTimeoutMs ?? LOCK_ACQUIRE_TIMEOUT_MS;
+    const deadline = Date.now() + acquireTimeoutMs;
+    // Carried into the timeout message. Without it every failure reads "locked by
+    // another writer", including the one case where there provably is no other
+    // writer — a stranded `.lock.steal` blocking the reclamation of a dead
+    // holder's lock — which points the operator at the wrong file for the single
+    // failure mode this design introduces.
+    let lastObservation = "the lock was not observed before the deadline";
+    for (;;) {
+        if (Date.now() >= deadline) {
+            throw new ExecutionError(`progress report session is locked by another writer and did not release within ${String(acquireTimeoutMs)}ms; ${lastObservation}`);
+        }
+        let created = false;
+        try {
+            const handle = await open(lockPath, "wx", 0o600);
+            try {
+                const body = {
+                    token,
+                    pid: process.pid,
+                    hostname: hostname(),
+                    acquired_at: new Date().toISOString(),
+                    heartbeat_interval_ms: LOCK_HEARTBEAT_MS,
+                };
+                created = true;
+                await handle.writeFile(JSON.stringify(body), "utf8");
+            }
+            finally {
+                await handle.close();
+            }
+            break;
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== "EEXIST") {
+                // We created the lock but could not write its body (ENOSPC, EIO). Leaving
+                // it behind would strand every future writer behind a fresh-looking lock
+                // that nobody owns and no PID probe can ever clear.
+                if (created)
+                    await unlink(lockPath).catch(() => undefined);
+                throw err;
+            }
+            const observation = await observeLock(lockPath);
+            if (observation.kind === "abandoned") {
+                const outcome = await reclaimAbandonedLock(lockPath, observation.token);
+                if (outcome.kind === "reclaimed") {
+                    lastObservation = `the lock was abandoned (${observation.why}) and was reclaimed`;
+                    logger.warn({ lockPath, reason: observation.why }, "progress-report: reclaiming abandoned session lock");
+                    // Real progress was made, so retry immediately rather than sleeping.
+                    continue;
+                }
+                // Reclamation was declined or lost: fall through to the backoff, so a
+                // repeatedly-failing reclaim waits out the deadline instead of spinning.
+                lastObservation =
+                    outcome.kind === "steal_lock_unavailable"
+                        ? outcome.code === "EEXIST"
+                            ? `the lock looks abandoned (${observation.why}) but reclamation was declined because the reclaim lock ${stealPathFor(lockPath)} already exists — if no writer is running, remove that file`
+                            : `the lock looks abandoned (${observation.why}) but the reclaim lock ${stealPathFor(lockPath)} could not be created (${outcome.code})`
+                        : outcome.kind === "superseded"
+                            ? `the lock looked abandoned (${observation.why}) but another writer replaced it first`
+                            : `the lock looks abandoned (${observation.why}) but it could not be deleted (${outcome.code})`;
+            }
+            else {
+                lastObservation =
+                    observation.kind === "live"
+                        ? "the lock is held by a writer that still looks alive"
+                        : `the lock could not be judged abandoned: ${observation.why}`;
+            }
+            await sleep(RETRY_BASE_MS + Math.floor(Math.random() * RETRY_JITTER_MS));
+        }
+    }
+    let ownershipLost = false;
+    let beating;
+    const heartbeat = setInterval(() => {
+        if (ownershipLost || beating !== undefined)
+            return;
+        const beat = (async () => {
+            const current = await readLockToken(lockPath);
+            if (current !== null && current !== token) {
+                // PROVEN loss: a complete, readable body whose token is not ours. An
+                // unreadable or absent lock is NOT proof and must not revoke our claim.
+                ownershipLost = true;
+                logger.warn({ lockPath }, "progress-report: session lock was taken from us");
+                return;
+            }
+            const at = new Date();
+            await utimes(lockPath, at, at).catch(() => undefined);
+        })().finally(() => {
+            beating = undefined;
+        });
+        beating = beat;
+    }, LOCK_HEARTBEAT_MS);
+    heartbeat.unref();
+    const guard = {
+        async assertHeld() {
+            if (ownershipLost || (await readLockToken(lockPath)) !== token) {
+                throw new ExecutionError("progress report session lock was reclaimed by another writer mid-update; nothing was written — re-read the report and retry");
+            }
+        },
+    };
+    try {
+        return await fn(guard);
+    }
+    finally {
+        clearInterval(heartbeat);
+        await beating?.catch(() => undefined);
+        if ((await readLockToken(lockPath)) === token) {
+            await unlink(lockPath).catch(() => undefined);
+        }
+    }
+}
+//# sourceMappingURL=lock.js.map

package/dist/progress-report/lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.js","sourceRoot":"","sources":["../../src/progress-report/lock.ts"],"names":[],"mappings":"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"}