@the-open-engine/zeroshot 6.1.0 → 6.3.0

package/cli/commands/cmdproof.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const crypto = require('crypto');
 const { spawnSync } = require('child_process');
 
 const {
@@ -153,6 +154,7 @@ function resolvePaths(env) {
   return {
     cacheDir,
     keyDir,
+    lockDir: env.ZEROSHOT_CMDPROOF_LOCK_DIR || path.join(root, 'locks'),
     privateKeyPath: path.join(keyDir, 'private-key.json'),
     publicKeyPath: path.join(keyDir, 'public-key.json'),
   };
@@ -180,6 +182,114 @@ function spawnCmdproof(args, options) {
   return result;
 }
 
+function parsePositiveInt(value, fallback) {
+  const parsed = Number.parseInt(String(value || ''), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function sleepMs(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function proofLockName(proof, verifyReport = null) {
+  const actionKey = getVerifyActionKey(verifyReport);
+  const digest = crypto
+    .createHash('sha256')
+    .update(`${proof.id}\0${proof.profile}\0${proof.command}\0${actionKey}`)
+    .digest('hex')
+    .slice(0, 16);
+  const safeId = proof.id.replace(/[^a-zA-Z0-9._-]/g, '_');
+  return `${safeId}-${digest}.lock`;
+}
+
+function getVerifyActionKey(verifyReport) {
+  return verifyReport?.actionKey || verifyReport?.action_key || '';
+}
+
+function proofLockPath(proof, paths, verifyReport = null) {
+  return path.join(paths.lockDir, proofLockName(proof, verifyReport));
+}
+
+function removeLock(lockPath) {
+  fs.rmSync(lockPath, { recursive: true, force: true });
+}
+
+function lockOwnerState(lockPath) {
+  try {
+    const metadata = JSON.parse(fs.readFileSync(path.join(lockPath, 'owner.json'), 'utf8'));
+    if (!Number.isInteger(metadata.pid) || metadata.pid <= 0) {
+      return 'unknown';
+    }
+    try {
+      process.kill(metadata.pid, 0);
+      return 'alive';
+    } catch (error) {
+      return error?.code === 'ESRCH' ? 'gone' : 'unknown';
+    }
+  } catch {
+    return 'unknown';
+  }
+}
+
+function lockIsStale(lockPath, staleMs) {
+  try {
+    const stat = fs.statSync(lockPath);
+    const ownerState = lockOwnerState(lockPath);
+    if (ownerState === 'alive') {
+      return false;
+    }
+    if (ownerState === 'gone') {
+      return true;
+    }
+    return Date.now() - stat.mtimeMs > staleMs;
+  } catch {
+    return false;
+  }
+}
+
+function writeLockMetadata(lockPath, proof) {
+  const metadata = {
+    pid: process.pid,
+    proofId: proof.id,
+    profile: proof.profile,
+    command: proof.command,
+    createdAt: new Date().toISOString(),
+  };
+  fs.writeFileSync(path.join(lockPath, 'owner.json'), `${JSON.stringify(metadata, null, 2)}\n`, {
+    mode: 0o600,
+  });
+}
+
+function tryAcquireProofLock(proof, paths, env, verifyReport = null) {
+  const lockPath = proofLockPath(proof, paths, verifyReport);
+  const staleMs = parsePositiveInt(env.ZEROSHOT_CMDPROOF_LOCK_STALE_MS, 6 * 60 * 60 * 1000);
+  fs.mkdirSync(paths.lockDir, { recursive: true, mode: 0o700 });
+
+  try {
+    fs.mkdirSync(lockPath, { mode: 0o700 });
+    writeLockMetadata(lockPath, proof);
+    return { acquired: true, lockPath };
+  } catch (error) {
+    if (error?.code !== 'EEXIST') {
+      throw error;
+    }
+    if (!lockIsStale(lockPath, staleMs)) {
+      return { acquired: false, lockPath };
+    }
+    removeLock(lockPath);
+    try {
+      fs.mkdirSync(lockPath, { mode: 0o700 });
+      writeLockMetadata(lockPath, proof);
+      return { acquired: true, lockPath };
+    } catch (retryError) {
+      if (retryError?.code === 'EEXIST') {
+        return { acquired: false, lockPath };
+      }
+      throw retryError;
+    }
+  }
+}
+
 function ensureKeypair(paths, options) {
   fs.mkdirSync(paths.cacheDir, { recursive: true, mode: 0o700 });
   fs.mkdirSync(paths.keyDir, { recursive: true, mode: 0o700 });
@@ -231,6 +341,74 @@ function runMode(mode, proof, paths, options) {
   return statusOf(result);
 }
 
+function runProveWithLock(proof, paths, options, lockPath) {
+  try {
+    return runMode('prove', proof, paths, options);
+  } finally {
+    removeLock(lockPath);
+  }
+}
+
+function verifyProof(proof, paths, options, { write = true } = {}) {
+  const result = spawnCmdproof(buildCmdproofArgs('verify', proof, paths), options);
+  if (write) {
+    writeResult(result, options.stdout, options.stderr);
+  }
+  return result;
+}
+
+function waitForProofOrProve(proof, paths, options, verifyReport) {
+  const startedAt = Date.now();
+  const waitMs = parsePositiveInt(options.env.ZEROSHOT_CMDPROOF_WAIT_MS, 30 * 60 * 1000);
+  const pollMs = parsePositiveInt(options.env.ZEROSHOT_CMDPROOF_POLL_MS, 2500);
+
+  while (Date.now() - startedAt < waitMs) {
+    sleepMs(pollMs);
+    const verifyResult = verifyProof(proof, paths, options, { write: false });
+    const latestReport = parseJsonObject(verifyResult.stdout) || verifyReport;
+    if (!shouldFallbackFromVerify(verifyResult)) {
+      writeResult(verifyResult, options.stdout, options.stderr);
+      return statusOf(verifyResult);
+    }
+
+    const lockReport = getVerifyActionKey(latestReport) ? latestReport : verifyReport;
+    const lock = tryAcquireProofLock(proof, paths, options.env, lockReport);
+    if (lock.acquired) {
+      options.stderr.write(
+        `zeroshot cmdproof check ${proof.id}: no reusable proof appeared; acquired proof lock after wait.\n`
+      );
+      return runProveWithLock(proof, paths, options, lock.lockPath);
+    }
+  }
+
+  options.stderr.write(
+    `zeroshot cmdproof check ${proof.id}: timed out waiting ${waitMs}ms for in-flight proof; leaving miss for caller.\n`
+  );
+  const finalVerify = verifyProof(proof, paths, options, { write: true });
+  return statusOf(finalVerify);
+}
+
+function runCheck(proof, paths, options) {
+  const verifyResult = verifyProof(proof, paths, options);
+  if (!shouldFallbackFromVerify(verifyResult)) {
+    return statusOf(verifyResult);
+  }
+  const verifyReport = parseJsonObject(verifyResult.stdout);
+  if (!getVerifyActionKey(verifyReport)) {
+    return runMode('prove', proof, paths, options);
+  }
+
+  const lock = tryAcquireProofLock(proof, paths, options.env, verifyReport);
+  if (lock.acquired) {
+    return runProveWithLock(proof, paths, options, lock.lockPath);
+  }
+
+  options.stderr.write(
+    `zeroshot cmdproof check ${proof.id}: proof miss; waiting for in-flight proof from another agent.\n`
+  );
+  return waitForProofOrProve(proof, paths, options, verifyReport);
+}
+
 function runCmdproof({
   mode,
   id,
@@ -250,12 +428,7 @@ function runCmdproof({
   ensureKeypair(paths, options);
 
   if (mode === 'check') {
-    const verifyResult = spawnCmdproof(buildCmdproofArgs('verify', proof, paths), options);
-    writeResult(verifyResult, stdout, stderr);
-    if (!shouldFallbackFromVerify(verifyResult)) {
-      return statusOf(verifyResult);
-    }
-    return runMode('prove', proof, paths, options);
+    return runCheck(proof, paths, options);
   }
 
   return runMode(mode, proof, paths, options);
@@ -265,4 +438,5 @@ module.exports = {
   buildCmdproofArgs,
   parseCommandToArgv,
   runCmdproof,
+  proofLockName,
 };

package/cli/event-copy.js

@@ -0,0 +1,12 @@
+const EVENT_COPY = {
+  IMPLEMENTATION_READY: 'Implementation ready',
+  PR_CREATED: 'Pull request created',
+};
+
+function formatMergeStatus(merged) {
+  if (merged === true || merged === 'true') return 'merged';
+  if (merged === false || merged === 'false') return 'auto-merge pending approval';
+  return null;
+}
+
+module.exports = { EVENT_COPY, formatMergeStatus };