@rightkit/release 0.2.40 → 0.2.41

package/build-release.mjs

@@ -23,6 +23,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { assertPrimaryReleaseCheckout, dirtyBuildInputs } from "./release-invocation.mjs";
 import { commandOutputPortable, releaseEnvironment, resolveReleaseLayout, runBuildStateMachine, verifySealedRelease, watchProgress } from "./release-state.mjs";
 import { acquireCacheLease, acquireSuiteBuildSlot, applyCachePrune, assertWriteVolumeFloors, inspectCache, inspectWriteVolumes, markCacheEntrySuccessful, planCachePrune, readCachePolicy, resolveCacheLayout, resolveSharedCacheIdentity, resolveSharedCacheRoot } from "./cache-policy.mjs";
+import { createTargetBridge } from "./target-bridge.mjs";
 
 const TOOL_ROOT = path.dirname(fileURLToPath(import.meta.url));
 const WORKER = path.join(TOOL_ROOT, "release.mjs");
@@ -125,8 +126,10 @@ try {
     tools: toolVersions,
     createdAt: new Date().toISOString(),
   };
+  const targetLink = path.join(appRoot, "src-tauri", "target");
+  const targetBridge = createTargetBridge({ link: targetLink, target: env.CARGO_TARGET_DIR });
 
-  const result = await runBuildStateMachine({
+  const result = await targetBridge.run(async () => runBuildStateMachine({
     root: repoRoot,
     app: config.app,
     version: config.version,
@@ -158,9 +161,9 @@ try {
       prepare: async () => {
         throwIfInterrupted();
         const cacheTarget = env.CARGO_TARGET_DIR;
-        const targetLink = path.join(appRoot, "src-tauri", "target");
         mkdirSync(cacheTarget, { recursive: true });
-        if (!existsSync(targetLink)) symlinkSync(cacheTarget, targetLink, process.platform === "win32" ? "junction" : "dir");
+        if (cacheMode === "shared") targetBridge.ensure();
+        else if (!existsSync(targetLink)) symlinkSync(cacheTarget, targetLink, process.platform === "win32" ? "junction" : "dir");
         else if (realpathSync(targetLink) !== realpathSync(cacheTarget)) {
           fail(`primary checkout target exists and is not the release cache link: ${targetLink}`);
         }
@@ -186,7 +189,7 @@ try {
         checkpoint(stateRoot, "sealed");
       },
     },
-  });
+  }));
   if (cacheMode === "shared") {
     const snapshot = inspectCache({ cacheRoot: sharedCacheRoot });
     const plan = planCachePrune({ snapshot, policy: readCachePolicy(process.env), protectedEntryIds: new Set([sharedLayout.id]) });

package/build-release.test.mjs

@@ -42,3 +42,9 @@ test("dirty release config is rejected before the config module is imported", ()
   assert.ok(guard >= 0, "config cleanliness guard must exist");
   assert.ok(guard < imported, "config cleanliness guard must run before module import");
 });
+
+test("shared Cache V2 target bridge is owned by a finally-cleaned lifecycle", () => {
+  assert.match(source, /createTargetBridge\(\{ link: targetLink, target: env\.CARGO_TARGET_DIR \}\)/);
+  assert.match(source, /targetBridge\.run\(.*runBuildStateMachine/s);
+  assert.match(source, /if \(cacheMode === "shared"\) targetBridge\.ensure\(\)/);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rightkit/release",
-  "version": "0.2.40",
+  "version": "0.2.41",
   "description": "Portable Right Suite release CLI/SDK: signed installers, updater artifacts, patch/update routing, hardening, R2 publish, and RightApps registration.",
   "type": "module",
   "bin": {

package/right-suite-contract.test.mjs

@@ -392,7 +392,7 @@ test("mac release config uses a dedicated non-recursive package entry point", ()
 test("RightKit exposes one current version manifest", () => {
   assert.equal(existsSync(versionsPath), true, "rightkit-versions.json must be the single current-version source");
   assert.match(versions.packageManager, /^pnpm@\d+\.\d+\.\d+$/);
-  assert.equal(versions.npm["@rightkit/release"], "0.2.40");
+  assert.equal(versions.npm["@rightkit/release"], "0.2.41");
   assert.equal(versions.npm["@rightkit/legal"], "0.2.0");
   assert.equal(versions.npm["@rightkit/license"], "0.1.5");
   assert.equal(versions.npm["@rightkit/logs"], "0.1.3");

package/rightkit-versions.json

@@ -7,7 +7,7 @@
     "@rightkit/logs": "0.1.3",
     "@rightkit/platform-ui": "0.1.0",
     "@rightkit/qa": "0.1.0",
-    "@rightkit/release": "0.2.40",
+    "@rightkit/release": "0.2.41",
     "@rightkit/tauri": "0.1.0",
     "@rightkit/updates": "0.2.3"
   },

package/target-bridge.mjs

@@ -0,0 +1,119 @@
+import { lstatSync, mkdirSync, realpathSync, symlinkSync, unlinkSync } from "node:fs";
+import path from "node:path";
+
+export function createTargetBridge({
+  link,
+  target,
+  platform = process.platform,
+  lstat = lstatSync,
+  mkdir = mkdirSync,
+  realpath = realpathSync,
+  symlink = symlinkSync,
+  unlink = unlinkSync,
+}) {
+  let acquired = false;
+  let created = false;
+  let ownership = null;
+
+  const bridge = {
+    ensure() {
+      mkdir(target, { recursive: true });
+      let entry = readEntry(link, lstat);
+      if (!entry) {
+        symlink(target, link, platform === "win32" ? "junction" : "dir");
+        entry = lstat(link);
+        if (!entry.isSymbolicLink()) throw new Error(`RightKit target bridge was not created as a symbolic link: ${link}`);
+        if (!sameRealPath(link, target, realpath, platform)) {
+          throw new Error(`RightKit target bridge is not the owned shared cache target after creation: ${link}`);
+        }
+        ownership = entryIdentity(entry);
+        created = true;
+      } else {
+        if (!entry.isSymbolicLink()) throw new Error(`primary checkout target is not a symbolic link; refusing to replace it: ${link}`);
+        if (!sameRealPath(link, target, realpath, platform)) {
+          throw new Error(`primary checkout target is not the owned shared cache target; refusing to replace it: ${link}`);
+        }
+      }
+      acquired = true;
+      return { created, link, target };
+    },
+
+    release() {
+      if (!acquired) return false;
+      if (!ownership) {
+        acquired = false;
+        return false;
+      }
+      const entry = readEntry(link, lstat);
+      if (!entry) {
+        acquired = false;
+        return false;
+      }
+      if (!sameEntry(entry, ownership)) {
+        acquired = false;
+        return false;
+      }
+      let exactOwnedTarget = false;
+      try {
+        exactOwnedTarget = sameRealPath(link, target, realpath, platform);
+      } catch (error) {
+        if (error?.code !== "ENOENT") throw error;
+      }
+      if (!exactOwnedTarget) {
+        acquired = false;
+        return false;
+      }
+      unlink(link);
+      acquired = false;
+      ownership = null;
+      return true;
+    },
+
+    async run(operation) {
+      let operationError;
+      try {
+        return await operation(bridge);
+      } catch (error) {
+        operationError = error;
+        throw error;
+      } finally {
+        try {
+          bridge.release();
+        } catch (cleanupError) {
+          if (!operationError) throw cleanupError;
+          operationError.cleanupError = cleanupError;
+        }
+      }
+    },
+  };
+
+  return bridge;
+}
+
+function entryIdentity(stats) {
+  return { dev: stats.dev, ino: stats.ino, symbolicLink: stats.isSymbolicLink() };
+}
+
+function sameEntry(stats, expected) {
+  return stats.dev === expected.dev
+    && stats.ino === expected.ino
+    && stats.isSymbolicLink() === expected.symbolicLink
+    && expected.symbolicLink;
+}
+
+function readEntry(file, lstat) {
+  try {
+    return lstat(file);
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+}
+
+function sameRealPath(left, right, realpath, platform) {
+  const canonical = (value) => {
+    const resolved = path.normalize(realpath(value));
+    return platform === "win32" ? resolved.toLowerCase() : resolved;
+  };
+  return canonical(left) === canonical(right);
+}

package/target-bridge.test.mjs

@@ -0,0 +1,155 @@
+import assert from "node:assert/strict";
+import { lstatSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { createTargetBridge } from "./target-bridge.mjs";
+
+function fixture() {
+  const root = mkdtempSync(path.join(os.tmpdir(), "rightkit-target-bridge-"));
+  const target = path.join(root, "shared", "target");
+  const link = path.join(root, "app", "src-tauri", "target");
+  mkdirSync(target, { recursive: true });
+  mkdirSync(path.dirname(link), { recursive: true });
+  writeFileSync(path.join(target, "keep.txt"), "shared-cache\n");
+  return { root, target, link };
+}
+
+test("removes an invocation-created bridge after success without touching the shared target", async () => {
+  const fx = fixture();
+  const bridge = createTargetBridge(fx);
+  await bridge.run(async () => {
+    bridge.ensure();
+    assert.equal(realpathSync(fx.link), realpathSync(fx.target));
+  });
+  assert.throws(() => lstatSync(fx.link), { code: "ENOENT" });
+  assert.equal(readFileSync(path.join(fx.target, "keep.txt"), "utf8"), "shared-cache\n");
+});
+
+test("removes an invocation-created bridge after the build throws", async () => {
+  const fx = fixture();
+  const bridge = createTargetBridge(fx);
+  await assert.rejects(
+    bridge.run(async () => {
+      bridge.ensure();
+      throw new Error("package failed");
+    }),
+    /package failed/,
+  );
+  assert.throws(() => lstatSync(fx.link), { code: "ENOENT" });
+});
+
+test("removes an invocation-created bridge after a signal-style abort", async () => {
+  const fx = fixture();
+  const bridge = createTargetBridge(fx);
+  await assert.rejects(
+    bridge.run(async () => {
+      bridge.ensure();
+      throw new Error("release interrupted by SIGTERM");
+    }),
+    /SIGTERM/,
+  );
+  assert.throws(() => lstatSync(fx.link), { code: "ENOENT" });
+});
+
+test("accepts but preserves a pre-existing exact shared-target bridge", async () => {
+  const fx = fixture();
+  symlinkSync(fx.target, fx.link, process.platform === "win32" ? "junction" : "dir");
+  await createTargetBridge(fx).run(async (bridge) => {
+    assert.deepEqual(bridge.ensure(), { created: false, link: fx.link, target: fx.target });
+  });
+  assert.equal(realpathSync(fx.link), realpathSync(fx.target));
+  assert.equal(readFileSync(path.join(fx.target, "keep.txt"), "utf8"), "shared-cache\n");
+});
+
+test("fails closed when the new bridge is replaced immediately after symlink creation", () => {
+  const fx = fixture();
+  const other = path.join(fx.root, "racing-target");
+  mkdirSync(other);
+  const bridge = createTargetBridge({
+    ...fx,
+    symlink(target, link, type) {
+      symlinkSync(target, link, type);
+      unlinkSync(link);
+      symlinkSync(other, link, type);
+    },
+  });
+  assert.throws(() => bridge.ensure(), /owned shared cache target/i);
+  assert.equal(realpathSync(fx.link), realpathSync(other));
+});
+
+test("fails closed and preserves an unrelated symlink", async () => {
+  const fx = fixture();
+  const other = path.join(fx.root, "other-target");
+  mkdirSync(other);
+  symlinkSync(other, fx.link, process.platform === "win32" ? "junction" : "dir");
+  await assert.rejects(
+    createTargetBridge(fx).run(async (bridge) => bridge.ensure()),
+    /not the owned shared cache target/i,
+  );
+  assert.equal(realpathSync(fx.link), realpathSync(other));
+});
+
+test("preserves a same-target symlink that replaces an acquired bridge", () => {
+  const fx = fixture();
+  let successfulStats = 0;
+  const bridge = createTargetBridge({
+    ...fx,
+    lstat(file) {
+      const stats = lstatSync(file);
+      successfulStats += 1;
+      if (successfulStats === 1) return stats;
+      return { dev: stats.dev, ino: stats.ino + 1, isSymbolicLink: () => stats.isSymbolicLink() };
+    },
+  });
+  bridge.ensure();
+  unlinkSync(fx.link);
+  symlinkSync(fx.target, fx.link, process.platform === "win32" ? "junction" : "dir");
+  assert.equal(bridge.release(), false);
+  assert.equal(realpathSync(fx.link), realpathSync(fx.target));
+});
+
+test("preserves a different-target symlink that replaces an acquired bridge", () => {
+  const fx = fixture();
+  const other = path.join(fx.root, "replacement-target");
+  mkdirSync(other);
+  const bridge = createTargetBridge(fx);
+  bridge.ensure();
+  unlinkSync(fx.link);
+  symlinkSync(other, fx.link, process.platform === "win32" ? "junction" : "dir");
+  assert.equal(bridge.release(), false);
+  assert.equal(realpathSync(fx.link), realpathSync(other));
+});
+
+test("fails closed and preserves a real target directory with user content", async () => {
+  const fx = fixture();
+  mkdirSync(fx.link);
+  writeFileSync(path.join(fx.link, "user.txt"), "keep\n");
+  await assert.rejects(
+    createTargetBridge(fx).run(async (bridge) => bridge.ensure()),
+    /not a symbolic link/i,
+  );
+  assert.equal(readFileSync(path.join(fx.link, "user.txt"), "utf8"), "keep\n");
+});
+
+test("cleanup is idempotent and reports process errors without masking a build failure", async () => {
+  const fx = fixture();
+  const bridge = createTargetBridge(fx);
+  bridge.ensure();
+  assert.equal(bridge.release(), true);
+  assert.equal(bridge.release(), false);
+
+  const cleanupFailure = new Error("unlink denied");
+  const failing = createTargetBridge({ ...fx, unlink: () => { throw cleanupFailure; } });
+  const buildFailure = new Error("build aborted");
+  await assert.rejects(
+    failing.run(async () => {
+      failing.ensure();
+      throw buildFailure;
+    }),
+    (error) => error === buildFailure && error.cleanupError === cleanupFailure,
+  );
+  assert.equal(lstatSync(fx.link).isSymbolicLink(), true);
+  unlinkSync(fx.link);
+});