@openlatch/client 0.5.4 → 0.5.7

package/README.md

@@ -149,6 +149,12 @@ Pick a [good first issue](https://github.com/OpenLatch/openlatch-client/labels/g
 
 - Report vulnerabilities to **security@openlatch.ai**; private vulnerability reporting is enabled on this repository
 - Every release binary carries a minisign signature, which the client verifies before it updates itself; macOS and Linux binaries also carry Sigstore signatures. What is and is not signed: [SECURITY.md](SECURITY.md)
+- Binary replacement is also policy-cache safe. Self-update and the npm/npx
+  launcher ask the candidate executable to load the exact resident bundle
+  before activation and retain a previous evaluator/binary pair if it cannot.
+  This proof is local and works offline; an update never fetches on the hook
+  verdict path. npm launcher state lives under `OPENLATCH_DIR` as
+  `npm-launcher.json` plus versioned `npm-bin/` pairs.
 - Full policy: [SECURITY.md](SECURITY.md)
 
 ## License

package/lib/postinstall.js

@@ -98,6 +98,10 @@ function downloadBinaries() {
 
 try {
   downloadBinaries();
+  // Package-manager installs use the same cache-reader proof and durable
+  // current/previous pair as the runtime launcher. Failure stays non-fatal to
+  // npm itself, but an incompatible candidate is not activated.
+  require("./resolve-binary").activateCandidate();
 } catch (err) {
   // Never fail the npm install — fail-open principle
   console.warn(`openlatch: postinstall warning — ${err.message}`);

package/lib/resolve-binary.js

@@ -8,6 +8,9 @@
 
 const path = require("path");
 const os = require("os");
+const fs = require("fs");
+const crypto = require("crypto");
+const { spawnSync } = require("child_process");
 
 const PLATFORMS = {
   "darwin-arm64": "@openlatch/client-darwin-arm64",
@@ -17,7 +20,7 @@ const PLATFORMS = {
   "win32-x64": "@openlatch/client-win32-x64",
 };
 
-function resolveBinary(baseName) {
+function resolveCandidate(baseName) {
   const platformKey = `${os.platform()}-${os.arch()}`;
   const pkg = PLATFORMS[platformKey];
 
@@ -42,4 +45,172 @@ function resolveBinary(baseName) {
   }
 }
 
-module.exports = { resolveBinary, PLATFORMS };
+function openlatchDir() {
+  return process.env.OPENLATCH_DIR || path.join(os.homedir(), ".openlatch");
+}
+
+function launcherStatePath() {
+  return path.join(openlatchDir(), "npm-launcher.json");
+}
+
+function readState() {
+  try {
+    return JSON.parse(fs.readFileSync(launcherStatePath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function writeState(state) {
+  const file = launcherStatePath();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.tmp`;
+  fs.writeFileSync(temporary, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+  fs.renameSync(temporary, file);
+}
+
+function preservePreGuardEvaluator(state) {
+  if (state.current) return state;
+  try {
+    const pid = fs.readFileSync(path.join(openlatchDir(), "daemon.pid"), "utf8").trim();
+    if (!/^\d+$/.test(pid)) return state;
+    const ext = os.platform() === "win32" ? ".exe" : "";
+    let runningExe;
+    let runningDir;
+    if (os.platform() === "linux") {
+      runningExe = `/proc/${pid}/exe`;
+      runningDir = path.dirname(fs.readlinkSync(runningExe).replace(/ \(deleted\)$/, ""));
+    } else if (os.platform() === "darwin") {
+      const query = spawnSync("ps", ["-p", pid, "-o", "comm="], { encoding: "utf8" });
+      runningExe = (query.stdout || "").trim();
+      runningDir = path.dirname(runningExe);
+    } else if (os.platform() === "win32") {
+      const query = spawnSync(
+        "powershell.exe",
+        ["-NoProfile", "-Command", `(Get-Process -Id ${pid}).Path`],
+        { encoding: "utf8" }
+      );
+      runningExe = (query.stdout || "").trim();
+      runningDir = path.dirname(runningExe);
+    } else {
+      return state;
+    }
+    if (!runningExe) return state;
+    const runningHook = process.env.OPENLATCH_HOOK_BIN || path.join(runningDir, `openlatch-hook${ext}`);
+    if (!fs.existsSync(runningHook)) return state;
+    const root = path.join(openlatchDir(), "npm-bin", `previous-${Date.now()}`);
+    fs.mkdirSync(root, { recursive: true });
+    fs.copyFileSync(runningExe, path.join(root, `openlatch${ext}`));
+    fs.copyFileSync(runningHook, path.join(root, `openlatch-hook${ext}`));
+    fs.chmodSync(path.join(root, `openlatch${ext}`), 0o755);
+    fs.chmodSync(path.join(root, `openlatch-hook${ext}`), 0o755);
+    const preserved = { ...state, current: root, previous: null };
+    writeState(preserved);
+    return preserved;
+  } catch {
+    return state;
+  }
+}
+
+function replacePairAtRecordedPaths(executable, hook, state) {
+  const ext = os.platform() === "win32" ? ".exe" : "";
+  if (!state.current) {
+    // With no prior pair to restore, make direct supervision/hook paths fail
+    // closed instead of letting an unreadable evaluator start fail-open.
+    for (const candidate of [executable, hook]) {
+      if (fs.existsSync(candidate)) fs.renameSync(candidate, `${candidate}.reader-blocked`);
+    }
+    return;
+  }
+  for (const [sourceName, destination] of [
+    [`openlatch${ext}`, executable],
+    [`openlatch-hook${ext}`, hook],
+  ]) {
+    const source = path.join(state.current, sourceName);
+    const temporary = `${destination}.reader-restore`;
+    fs.copyFileSync(source, temporary);
+    if (os.platform() !== "win32") fs.chmodSync(temporary, 0o755);
+    // Windows rename does not replace an existing destination. The candidate
+    // is not running yet (this is postinstall), so remove it before installing
+    // the preserved bytes; POSIX follows the same explicit path.
+    fs.rmSync(destination, { force: true });
+    fs.renameSync(temporary, destination);
+  }
+}
+
+/**
+ * Copy a candidate pair into a durable current/previous launcher directory,
+ * then activate it only after the candidate itself proves resident-cache
+ * readability. npm and npx therefore share the native updater's guard instead
+ * of replacing the evaluator merely because package resolution changed.
+ */
+function activateCandidate() {
+  const executable = resolveCandidate("openlatch");
+  const hook = resolveCandidate("openlatch-hook");
+  if (!fs.existsSync(executable) || !fs.existsSync(hook)) return readState();
+
+  const stat = fs.statSync(executable);
+  const identity = crypto
+    .createHash("sha256")
+    .update(`${executable}:${stat.size}:${stat.mtimeMs}`)
+    .digest("hex")
+    .slice(0, 20);
+  const root = path.join(openlatchDir(), "npm-bin", identity);
+  const ext = os.platform() === "win32" ? ".exe" : "";
+  const stagedExe = path.join(root, `openlatch${ext}`);
+  const stagedHook = path.join(root, `openlatch-hook${ext}`);
+  const existing = readState();
+  if (existing.current === root && fs.existsSync(stagedExe) && fs.existsSync(stagedHook)) {
+    return existing;
+  }
+  fs.mkdirSync(root, { recursive: true });
+  fs.copyFileSync(executable, stagedExe);
+  fs.copyFileSync(hook, stagedHook);
+  if (os.platform() !== "win32") {
+    fs.chmodSync(stagedExe, 0o755);
+    fs.chmodSync(stagedHook, 0o755);
+  }
+
+  const proof = spawnSync(stagedExe, ["__reader-check", "--cache", openlatchDir()], {
+    encoding: "utf8",
+    timeout: 10000,
+  });
+  const state = preservePreGuardEvaluator(readState());
+  if (proof.status !== 0) {
+    if (state.current) {
+      replacePairAtRecordedPaths(executable, hook, state);
+      console.warn(
+        `openlatch: candidate reader check failed; preserving previous evaluator (${(proof.stderr || "").trim()})`
+      );
+      return state;
+    }
+    replacePairAtRecordedPaths(executable, hook, state);
+    throw new Error(
+      `candidate cannot read the resident policy cache and no previous evaluator is available: ${(proof.stderr || "reader check failed").trim()}`
+    );
+  }
+  if (state.current !== root) {
+    writeState({ current: root, previous: state.current || null, activated_at: new Date().toISOString() });
+  }
+  return readState();
+}
+
+function resolveBinary(baseName) {
+  const ext = os.platform() === "win32" ? ".exe" : "";
+  // The main command is the activation boundary. The hook is latency-critical
+  // and only follows the already-activated pair.
+  const state = baseName === "openlatch" ? activateCandidate() : readState();
+  if (state.current) {
+    const selected = path.join(state.current, `${baseName}${ext}`);
+    if (fs.existsSync(selected)) return selected;
+  }
+  return resolveCandidate(baseName);
+}
+
+module.exports = {
+  resolveBinary,
+  resolveCandidate,
+  activateCandidate,
+  replacePairAtRecordedPaths,
+  PLATFORMS,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openlatch/client",
-  "version": "0.5.4",
+  "version": "0.5.7",
   "description": "OpenLatch runtime enforcement node — the capture-and-enforce adapter that evaluates every covered action against a coding agent's Autonomy Zone before it runs",
   "license": "Apache-2.0",
   "repository": {
@@ -20,10 +20,10 @@
     "postinstall": "node lib/postinstall.js"
   },
   "optionalDependencies": {
-    "@openlatch/client-darwin-arm64": "0.5.4",
-    "@openlatch/client-darwin-x64": "0.5.4",
-    "@openlatch/client-linux-x64": "0.5.4",
-    "@openlatch/client-linux-arm64": "0.5.4",
-    "@openlatch/client-win32-x64": "0.5.4"
+    "@openlatch/client-darwin-arm64": "0.5.7",
+    "@openlatch/client-darwin-x64": "0.5.7",
+    "@openlatch/client-linux-x64": "0.5.7",
+    "@openlatch/client-linux-arm64": "0.5.7",
+    "@openlatch/client-win32-x64": "0.5.7"
   }
 }