@hackerrank/astra-cli 0.1.8 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hackerrank/astra-cli",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Minimal zero-dependency AI coding agent for the HackerRank AI Gateway.",
   "type": "module",
   "bin": {

package/src/ledger.js

@@ -15,6 +15,40 @@ function atomicWrite(file, value) {
   fs.renameSync(temp, file);
 }
 
+function sleepSync(milliseconds) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+}
+
+function withLedgerLock(file, callback) {
+  const lock = `${file}.lock`;
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const deadline = Date.now() + 30000;
+  let descriptor;
+  while (Date.now() < deadline) {
+    try {
+      descriptor = fs.openSync(lock, "wx");
+      break;
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+      sleepSync(20);
+    }
+  }
+  if (descriptor === undefined) throw new Error(`timed out waiting for benchmark ledger lock: ${file}`);
+  try {
+    return callback();
+  } finally {
+    try { fs.closeSync(descriptor); } catch {}
+    try { fs.rmSync(lock, { force: true }); } catch {}
+  }
+}
+
+function readLatest(ledger) {
+  if (!fs.existsSync(ledger.path)) return { version: LEDGER_VERSION, cells: {} };
+  const value = JSON.parse(fs.readFileSync(ledger.path, "utf8"));
+  if (value.version !== LEDGER_VERSION || !value.cells || typeof value.cells !== "object") throw new Error("invalid benchmark ledger");
+  return value;
+}
+
 export function loadLedger(file) {
   if (!fs.existsSync(file)) return { version: LEDGER_VERSION, cells: {}, path: file };
   const value = JSON.parse(fs.readFileSync(file, "utf8"));
@@ -30,28 +64,37 @@ function nextRunPath(ledger, cell) {
 }
 
 export function claimCell(ledger, cell) {
-  const existing = ledger.cells[cell.cellKey];
-  if (existing) return existing;
-  const record = {
-    ...cell,
-    status: "pending",
-    runPath: nextRunPath(ledger, cell),
-    createdAt: new Date().toISOString(),
-    leaseAt: null,
-  };
-  ledger.cells[cell.cellKey] = record;
-  atomicWrite(ledger.path, { version: LEDGER_VERSION, cells: ledger.cells });
-  return record;
+  return withLedgerLock(ledger.path, () => {
+    const latest = readLatest(ledger);
+    ledger.cells = latest.cells;
+    const existing = ledger.cells[cell.cellKey];
+    if (existing) return existing;
+    const record = {
+      ...cell,
+      status: "pending",
+      runPath: nextRunPath(ledger, cell),
+      createdAt: new Date().toISOString(),
+      leaseAt: null,
+    };
+    ledger.cells[cell.cellKey] = record;
+    atomicWrite(ledger.path, { version: LEDGER_VERSION, cells: ledger.cells });
+    return record;
+  });
 }
 
 export function transitionCell(ledger, cellKey, status, patch = {}) {
-  const cell = ledger.cells[cellKey];
-  if (!cell) throw new Error(`unknown benchmark cell: ${cellKey}`);
-  const next = { ...cell, ...patch, status, updatedAt: new Date().toISOString() };
-  if (["generating", "verifying"].includes(status) && patch.leaseAt === undefined) next.leaseAt = next.updatedAt;
-  ledger.cells[cellKey] = next;
-  atomicWrite(ledger.path, { version: LEDGER_VERSION, cells: ledger.cells });
-  return next;
+  return withLedgerLock(ledger.path, () => {
+    const localCell = ledger.cells[cellKey];
+    const latest = readLatest(ledger);
+    ledger.cells = latest.cells;
+    const cell = ledger.cells[cellKey] || localCell;
+    if (!cell) throw new Error(`unknown benchmark cell: ${cellKey}`);
+    const next = { ...cell, ...patch, status, updatedAt: new Date().toISOString() };
+    if (["generating", "verifying"].includes(status) && patch.leaseAt === undefined) next.leaseAt = next.updatedAt;
+    ledger.cells[cellKey] = next;
+    atomicWrite(ledger.path, { version: LEDGER_VERSION, cells: ledger.cells });
+    return next;
+  });
 }
 
 export function selectWork(ledger, desiredCells, now = Date.now(), { force = false, sessionId = null } = {}) {

package/src/verifier-runner.js

@@ -53,6 +53,18 @@ async function acquireVerifierLock(projectRoot, timeoutSeconds) {
       };
     } catch (error) {
       if (error?.code !== "EEXIST") throw error;
+      // A killed benchmark worker cannot run its finally block. Reclaim only
+      // a lock whose recorded owner is no longer alive; active workers keep
+      // exclusive ownership of fixed Docker ports.
+      try {
+        const owner = Number(fs.readFileSync(lockPath, "utf8").trim());
+        process.kill(owner, 0);
+      } catch (ownerError) {
+        if (ownerError?.code === "ESRCH" || !Number.isInteger(Number(fs.readFileSync(lockPath, "utf8").trim()))) {
+          try { fs.rmSync(lockPath, { force: true }); } catch {}
+          continue;
+        }
+      }
       await new Promise((resolve) => setTimeout(resolve, 100));
     }
   }