@hackerrank/astra-cli 0.1.7 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hackerrank/astra-cli",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "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/model.js

@@ -42,7 +42,7 @@ export class GatewayModel {
    * @param {number} [opts.maxRetries]
    * @param {(info:object)=>void} [opts.onRetry] called before each retry sleep
    */
-  constructor({ model, baseUrl, apiKey, modelKwargs = {}, maxRetries = 5, maxTokens = 8192, onRetry } = {}) {
+  constructor({ model, baseUrl, apiKey, modelKwargs = {}, maxRetries = 5, maxTokens = 8192, requestTimeoutMs = 300000, onRetry } = {}) {
     if (!model) throw new Error("GatewayModel: `model` is required");
     this.model = model;
     this.maxTokens = maxTokens;
@@ -50,6 +50,7 @@ export class GatewayModel {
     this.apiKey = apiKey || process.env.ASTRA_GATEWAY_API_KEY || "";
     this.modelKwargs = modelKwargs;
     this.maxRetries = maxRetries;
+    this.requestTimeoutMs = requestTimeoutMs;
     this.onRetry = onRetry || (() => {});
     this.nCalls = 0;
     // Cumulative token usage across all calls (exact, from the API).
@@ -96,6 +97,8 @@ export class GatewayModel {
     let lastErr;
     for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
       try {
+        const timeoutSignal = AbortSignal.timeout(this.requestTimeoutMs);
+        const signal = this.signal ? AbortSignal.any([this.signal, timeoutSignal]) : timeoutSignal;
         const res = await fetch(`${this.baseUrl}/chat/completions`, {
           method: "POST",
           headers: {
@@ -103,7 +106,7 @@ export class GatewayModel {
             Authorization: `Bearer ${this.apiKey}`,
           },
           body: JSON.stringify(body),
-          signal: this.signal || undefined,
+          signal,
         });
 
         if (!res.ok) {