@rightkit/release 0.2.68 → 0.2.70

package/cache-policy.test.mjs

@@ -1,346 +0,0 @@
-import assert from "node:assert/strict";
-import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, rmSync, symlinkSync, utimesSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import test from "node:test";
-import { spawn } from "node:child_process";
-import { once } from "node:events";
-
-import {
-  CACHE_SCHEMA,
-  DEFAULT_BACKUP_RETENTION_DAYS,
-  DEFAULT_DESIRED_FREE_BYTES,
-  DEFAULT_HARD_FREE_BYTES,
-  DEFAULT_SCCACHE_MAX_BYTES,
-  DEFAULT_TARGET_MAX_BYTES,
-  acquireCacheLease,
-  acquireSuiteBuildSlot,
-  applyCachePrune,
-  assertWriteVolumeFloors,
-  ensureCacheEntry,
-  inspectCache,
-  inspectWriteVolumes,
-  markCacheEntrySuccessful,
-  migrateLegacyCache,
-  planCachePrune,
-  readCachePolicy,
-  resolveCacheLayout,
-  resolveSharedCacheIdentity,
-  resolveSharedCacheRoot,
-  resolveStableRoot,
-} from "./cache-policy.mjs";
-
-function root() { return path.join(os.tmpdir(), `rightkit-cache-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`); }
-function layout(dir, fingerprint = "a1b2c3d4e5f60708") {
-  return resolveCacheLayout({ cacheRoot: dir, platform: "mac", architecture: "aarch64", app: "fixture", fingerprint, kind: "release" });
-}
-
-function migrationFixture() {
-  const base = root();
-  const fingerprint = "abcdef0123456789";
-  const legacyRoot = path.join(base, "repo", "app", "src-tauri", "target");
-  const legacyTargetRoot = path.join(base, "repo", ".right-release", "cache", "cargo-target", "mac", fingerprint);
-  const legacyCargoHome = path.join(base, "repo", ".right-release", "cache", "cargo-home");
-  mkdirSync(legacyTargetRoot, { recursive: true });
-  writeFileSync(path.join(legacyTargetRoot, "artifact"), "legacy-target");
-  mkdirSync(legacyCargoHome, { recursive: true });
-  writeFileSync(path.join(legacyCargoHome, "registry"), "legacy-cargo-home");
-  mkdirSync(path.dirname(legacyRoot), { recursive: true });
-  symlinkSync(legacyTargetRoot, legacyRoot);
-  const sharedCacheRoot = path.join(base, "shared-cache");
-  return {
-    fingerprint,
-    legacyRoot,
-    legacyTargetRoot,
-    legacyCargoHome,
-    layout: layout(sharedCacheRoot, fingerprint),
-    app: "fixture",
-    legacyReleaseLockPath: path.join(base, "repo", ".right-release", "locks", "mac.lock.json"),
-  };
-}
-
-test("cache roots are platform-native and overrides must be absolute", () => {
-  assert.throws(() => resolveSharedCacheRoot({ platform: "mac", home: "/Users/test", env: {} }), /RIGHT_RELEASE_CACHE_ROOT is required/);
-  assert.equal(resolveSharedCacheRoot({ platform: "win", env: { LOCALAPPDATA: "C:/Users/test/AppData/Local" } }), "C:\\Users\\test\\AppData\\Local\\RightSuite\\Cache\\release");
-  assert.equal(resolveSharedCacheRoot({ platform: "linux", home: "/home/test", env: {} }), "/home/test/.cache/rightsuite/release");
-  assert.equal(resolveSharedCacheRoot({ platform: "mac", env: { RIGHT_RELEASE_CACHE_ROOT: "/tmp/cache" } }), "/tmp/cache");
-  assert.throws(() => resolveSharedCacheRoot({ platform: "mac", env: { RIGHT_RELEASE_CACHE_ROOT: "relative" } }), /absolute/i);
-});
-
-test("shared cache root ignores XDG_CACHE_HOME regardless of value", () => {
-  assert.equal(
-    resolveSharedCacheRoot({ platform: "linux", env: { XDG_CACHE_HOME: "/one/path" }, home: "/home/u" }),
-    resolveSharedCacheRoot({ platform: "linux", env: {}, home: "/home/u" }),
-  );
-  assert.equal(resolveSharedCacheRoot({ platform: "linux", env: { XDG_CACHE_HOME: "/one/path" }, home: "/home/u" }), "/home/u/.cache/rightsuite/release");
-  // resolveSharedCacheRoot no longer accepts an xdgCacheHome option; passing one has no effect.
-  assert.equal(
-    resolveSharedCacheRoot({ platform: "linux", env: {}, home: "/home/u", xdgCacheHome: "/should/be/ignored" }),
-    "/home/u/.cache/rightsuite/release",
-  );
-});
-
-test("resolveStableRoot: explicit override wins, win32 requires the env var, other platforms ignore arbitrary env", () => {
-  const opts = {
-    darwinSegments: ["Library", "Caches", "Example"],
-    win32Segments: ["Example"],
-    otherSegments: ["example"],
-  };
-  assert.equal(
-    resolveStableRoot({ ...opts, platform: "linux", explicitOverride: "/explicit/path", overrideName: "EXAMPLE_ROOT", env: { EXAMPLE_ROOT: "ignored-by-caller-arg" } }),
-    "/explicit/path",
-  );
-  assert.throws(
-    () => resolveStableRoot({ ...opts, platform: "linux", explicitOverride: "relative/path", overrideName: "EXAMPLE_ROOT" }),
-    /EXAMPLE_ROOT must be an absolute path/,
-  );
-  assert.throws(
-    () => resolveStableRoot({ ...opts, platform: "win32", env: {} }),
-    /LOCALAPPDATA must be an absolute path for RightSuite/,
-  );
-  assert.equal(
-    resolveStableRoot({ ...opts, platform: "win32", env: { LOCALAPPDATA: "C:/Users/test/AppData/Local" } }),
-    "C:\\Users\\test\\AppData\\Local\\Example",
-  );
-  assert.equal(
-    resolveStableRoot({ ...opts, platform: "linux", env: { XDG_CACHE_HOME: "/ignored", npm_config_cache: "/ignored" }, home: "/home/u" }),
-    "/home/u/.cache/example",
-  );
-});
-
-test("layout isolates app, platform, kind, and fingerprint", () => {
-  const base = root();
-  const release = layout(base);
-  const testLayout = resolveCacheLayout({ cacheRoot: base, platform: "mac", architecture: "aarch64", app: "other", fingerprint: "a1b2c3d4e5f60708", kind: "test" });
-  assert.match(release.targetDir, /targets[\\/]mac[\\/]fixture[\\/]a1b2c3d4e5f60708$/);
-  assert.match(testLayout.targetDir, /test-targets[\\/]mac[\\/]other[\\/]a1b2c3d4e5f60708$/);
-  assert.notEqual(release.targetDir, testLayout.targetDir);
-});
-
-test("policy defaults are the approved target, compiler, desired and hard limits", () => {
-  const policy = readCachePolicy({});
-  assert.equal(CACHE_SCHEMA, 1);
-  assert.equal(policy.targetMaxBytes, DEFAULT_TARGET_MAX_BYTES);
-  assert.equal(policy.sccacheMaxBytes, DEFAULT_SCCACHE_MAX_BYTES);
-  assert.equal(policy.desiredFreeBytes, DEFAULT_DESIRED_FREE_BYTES);
-  assert.equal(policy.hardFreeBytes, DEFAULT_HARD_FREE_BYTES);
-  assert.equal(policy.backupRetentionDays, DEFAULT_BACKUP_RETENTION_DAYS);
-});
-
-test("pruning expires only old direct backup directories", () => {
-  const base = root();
-  const old = path.join(base, "manual-backups", "old-target");
-  const recent = path.join(base, "recovery", "recent-target");
-  const outside = root();
-  mkdirSync(old, { recursive: true }); writeFileSync(path.join(old, "artifact"), "old");
-  mkdirSync(recent, { recursive: true }); writeFileSync(path.join(recent, "artifact"), "recent");
-  mkdirSync(outside, { recursive: true });
-  mkdirSync(path.join(base, "legacy-backups"), { recursive: true });
-  symlinkSync(outside, path.join(base, "legacy-backups", "escape"));
-  utimesSync(old, new Date("2026-07-01T00:00:00Z"), new Date("2026-07-01T00:00:00Z"));
-  utimesSync(recent, new Date("2026-08-07T00:00:00Z"), new Date("2026-08-07T00:00:00Z"));
-  const snapshot = inspectCache({ cacheRoot: base, now: new Date("2026-08-08T00:00:00Z"), statfs: () => ({ bavail: 100, bsize: 1 }) });
-  assert.deepEqual(snapshot.backups.map((entry) => entry.id).sort(), ["backup:manual-backups:old-target", "backup:recovery:recent-target"]);
-  const plan = planCachePrune({ snapshot, policy: { ...readCachePolicy({}), targetMaxBytes: 1, desiredFreeBytes: 0 } });
-  assert.deepEqual(plan.candidateIds, ["backup:manual-backups:old-target"]);
-  const result = applyCachePrune({ plan, cacheRoot: base, dryRun: false });
-  assert.deepEqual(result.removedIds, ["backup:manual-backups:old-target"]);
-  assert.equal(existsSync(old), false);
-  assert.equal(existsSync(recent), true);
-  assert.equal(existsSync(outside), true);
-});
-
-test("entry metadata is atomic, complete, and updates success only after requested", () => {
-  const entry = layout(root());
-  ensureCacheEntry({ layout: entry, metadata: { toolchain: { cargo: "cargo 1", rustc: "rustc 1", host: "host" } }, now: new Date("2026-07-21T00:00:00Z") });
-  const created = JSON.parse(readFileSync(entry.markerPath, "utf8"));
-  assert.equal(created.schema, CACHE_SCHEMA);
-  assert.equal(created.id, "target:mac:fixture:a1b2c3d4e5f60708");
-  assert.equal(created.lastSuccessfulBuildAt, null);
-  markCacheEntrySuccessful({ layout: entry, now: new Date("2026-07-21T01:00:00Z") });
-  assert.equal(JSON.parse(readFileSync(entry.markerPath, "utf8")).lastSuccessfulBuildAt, "2026-07-21T01:00:00.000Z");
-});
-
-test("entry leases protect live entries, reclaim stale owners, and suite slots time out without a fallback", () => {
-  const entry = layout(root());
-  ensureCacheEntry({ layout: entry });
-  const lease = acquireCacheLease({ layout: entry, pid: process.pid, argv: ["test"] });
-  assert.throws(() => acquireCacheLease({ layout: entry, pid: process.pid + 100000, argv: ["second"] }), /lease.*active/i);
-  lease.release();
-  writeFileSync(entry.leasePath, JSON.stringify({ pid: 99999999, createdAt: "2000-01-01T00:00:00.000Z" }));
-  const reclaimed = acquireCacheLease({ layout: entry, pid: process.pid, argv: ["reclaimed"] });
-  reclaimed.release();
-  const slot = acquireSuiteBuildSlot({ layout: entry, pid: process.pid, argv: ["holder"], waitMs: 0 });
-  assert.throws(() => acquireSuiteBuildSlot({ layout: entry, pid: process.pid + 100000, argv: ["waiter"], waitMs: 0, sleep: () => {} }), /suite build slot.*active|timed out/i);
-  slot.release();
-});
-
-test("build and migration derive identical native-feature cache fingerprints", () => {
-  const base = root(); const cargoLock = path.join(base, "Cargo.lock"); const cargoToml = path.join(base, "Cargo.toml");
-  mkdirSync(base, { recursive: true });
-  writeFileSync(cargoLock, "[[package]]\nname = 'fixture'\n");
-  writeFileSync(cargoToml, "[dependencies]\nrusqlite = { version = '1', features = [\"bundled-sqlcipher\"] }\n");
-  const inputs = { cargoLockPath: cargoLock, cargoTomlPath: cargoToml, rustcVerbose: "rustc 1.91.0\nhost: aarch64-apple-darwin", targetTriple: "aarch64-apple-darwin", profile: "release" };
-  const build = resolveSharedCacheIdentity(inputs);
-  const migration = resolveSharedCacheIdentity(inputs);
-  assert.equal(build.fingerprint, migration.fingerprint);
-  assert.notEqual(build.fingerprint, resolveSharedCacheIdentity({ ...inputs, features: [] }).fingerprint);
-});
-
-test("cache identity ignores local workspace version bumps but keeps registry dependency identity", () => {
-  const base = root();
-  const cargoLock = path.join(base, "Cargo.lock");
-  mkdirSync(base, { recursive: true });
-  const lock = (appVersion, depVersion, checksum) => `version = 4\n\n[[package]]\nname = "fixture"\nversion = "${appVersion}"\ndependencies = [\n "serde",\n]\n\n[[package]]\nname = "serde"\nversion = "${depVersion}"\nsource = "registry+https://github.com/rust-lang/crates.io-index"\nchecksum = "${checksum}"\n`;
-  const inputs = { cargoLockPath: cargoLock, rustcVerbose: "rustc 1.91.0\nhost: aarch64-apple-darwin", targetTriple: "aarch64-apple-darwin" };
-
-  writeFileSync(cargoLock, lock("1.0.0", "1.0.0", "aaa"));
-  const original = resolveSharedCacheIdentity(inputs);
-  writeFileSync(cargoLock, lock("1.0.1", "1.0.0", "aaa"));
-  assert.equal(resolveSharedCacheIdentity(inputs).fingerprint, original.fingerprint);
-  writeFileSync(cargoLock, lock("1.0.1", "1.0.1", "bbb"));
-  assert.notEqual(resolveSharedCacheIdentity(inputs).fingerprint, original.fingerprint);
-});
-
-test("migration moves an actual src-tauri target symlink and keeps dry-run physically pure", () => {
-  const fixture = migrationFixture();
-  const preview = migrateLegacyCache({ ...fixture, dryRun: true });
-  assert.equal(preview.moved, false);
-  assert.equal(existsSync(fixture.layout.cacheRoot), false);
-  assert.equal(lstatSync(fixture.legacyRoot).isSymbolicLink(), true);
-  const result = migrateLegacyCache({ ...fixture, dryRun: false });
-  assert.equal(result.moved, true);
-  assert.equal(existsSync(fixture.legacyRoot), false);
-  assert.equal(readFileSync(path.join(fixture.layout.targetDir, "artifact"), "utf8"), "legacy-target");
-  assert.equal(readFileSync(path.join(fixture.layout.cargoHome, "registry"), "utf8"), "legacy-cargo-home");
-});
-
-test("migration rejects target symlinks outside the exact derived fingerprint directory", () => {
-  const fixture = migrationFixture();
-  const other = path.join(path.dirname(fixture.legacyTargetRoot), "other-fingerprint");
-  mkdirSync(other, { recursive: true });
-  symlinkSync(other, `${fixture.legacyRoot}-wrong`);
-  assert.throws(() => migrateLegacyCache({ ...fixture, legacyRoot: `${fixture.legacyRoot}-wrong`, dryRun: true }), /unexpected target link/i);
-  symlinkSync(path.join(other, "missing"), `${fixture.legacyRoot}-dangling`);
-  assert.throws(() => migrateLegacyCache({ ...fixture, legacyRoot: `${fixture.legacyRoot}-dangling`, dryRun: true }), /unexpected target link/i);
-});
-
-test("migration rolls back target, Cargo home, and src-tauri link after every injected post-move failure", () => {
-  for (const failureAt of ["after-target-move", "after-entry-marker", "after-cargo-home-move", "before-receipt", "receipt-write"]) {
-    const fixture = migrationFixture();
-    assert.throws(() => migrateLegacyCache({ ...fixture, dryRun: false, onPostMove: (step) => { if (step === failureAt) throw new Error(`injected ${step}`); }, writeMigrationReceipt: failureAt === "receipt-write" ? () => { throw new Error("injected receipt write"); } : undefined }), /injected/);
-    assert.equal(readFileSync(path.join(fixture.legacyTargetRoot, "artifact"), "utf8"), "legacy-target", failureAt);
-    assert.equal(realpathSync(fixture.legacyRoot), realpathSync(fixture.legacyTargetRoot), failureAt);
-    assert.equal(lstatSync(fixture.legacyRoot).isSymbolicLink(), true, failureAt);
-    assert.equal(readFileSync(path.join(fixture.legacyCargoHome, "registry"), "utf8"), "legacy-cargo-home", failureAt);
-    assert.equal(existsSync(fixture.layout.targetDir), false, failureAt);
-    assert.equal(existsSync(fixture.layout.cargoHome), false, failureAt);
-  }
-});
-
-test("a competing suite build slot blocks migration before it moves a legacy cache", () => {
-  const fixture = migrationFixture();
-  const slot = acquireSuiteBuildSlot({ layout: fixture.layout, pid: process.pid, argv: ["build"], waitMs: 0 });
-  try {
-    assert.throws(() => migrateLegacyCache({ ...fixture, dryRun: false, waitMs: 0 }), /suite build slot.*active|timed out/i);
-    assert.equal(realpathSync(fixture.legacyRoot), realpathSync(fixture.legacyTargetRoot));
-    assert.equal(existsSync(fixture.layout.targetDir), false);
-  } finally { slot.release(); }
-});
-
-test("a live shared build lease blocks migration during in-lock revalidation", () => {
-  const fixture = migrationFixture();
-  mkdirSync(fixture.layout.leasesDir, { recursive: true });
-  writeFileSync(path.join(fixture.layout.leasesDir, "another-build.json"), JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() }));
-  assert.throws(() => migrateLegacyCache({ ...fixture, dryRun: false }), /shared entry lease is live/i);
-  assert.equal(realpathSync(fixture.legacyRoot), realpathSync(fixture.legacyTargetRoot));
-  assert.equal(existsSync(fixture.layout.targetDir), false);
-  assert.equal(existsSync(fixture.layout.gcLockPath), false);
-  assert.equal(existsSync(fixture.layout.suiteSlotPath), false);
-});
-
-test("a live legacy release lock blocks migration during in-lock revalidation", () => {
-  const fixture = migrationFixture();
-  mkdirSync(path.dirname(fixture.legacyReleaseLockPath), { recursive: true });
-  writeFileSync(fixture.legacyReleaseLockPath, JSON.stringify({ pid: process.pid }));
-  assert.throws(() => migrateLegacyCache({ ...fixture, dryRun: false }), /legacy release lock is live/i);
-  assert.equal(realpathSync(fixture.legacyRoot), realpathSync(fixture.legacyTargetRoot));
-  assert.equal(existsSync(fixture.layout.targetDir), false);
-  assert.equal(existsSync(fixture.layout.gcLockPath), false);
-  assert.equal(existsSync(fixture.layout.suiteSlotPath), false);
-});
-
-test("pruning is oldest successful use first and dry-run equals apply candidates", () => {
-  const base = root();
-  const older = layout(base, "1111111111111111");
-  const newer = layout(base, "2222222222222222");
-  for (const [entry, stamp] of [[older, "2026-01-01T00:00:00.000Z"], [newer, "2026-02-01T00:00:00.000Z"]]) {
-    ensureCacheEntry({ layout: entry, now: new Date(stamp) });
-    writeFileSync(path.join(entry.targetDir, "payload"), "x".repeat(32));
-    markCacheEntrySuccessful({ layout: entry, now: new Date(stamp) });
-  }
-  const snapshot = { cacheRoot: base, targetBytes: 64, entries: [
-    { id: newer.id, dir: newer.targetDir, bytes: 32, marker: JSON.parse(readFileSync(newer.markerPath)), leased: false },
-    { id: older.id, dir: older.targetDir, bytes: 32, marker: JSON.parse(readFileSync(older.markerPath)), leased: false },
-  ] };
-  const plan = planCachePrune({ snapshot, policy: { targetMaxBytes: 31, desiredFreeBytes: 0 }, protectedEntryIds: new Set() });
-  assert.deepEqual(plan.candidates.map((x) => x.id), [older.id, newer.id]);
-  assert.deepEqual(applyCachePrune({ plan, cacheRoot: base, dryRun: true }).candidateIds, applyCachePrune({ plan, cacheRoot: base, dryRun: false }).candidateIds);
-  assert.equal(existsSync(older.targetDir), false);
-  assert.equal(existsSync(newer.targetDir), false);
-});
-
-test("pruning fails closed for malformed markers, symlink escapes, and cache root", () => {
-  const base = root();
-  const safe = layout(base);
-  mkdirSync(safe.targetDir, { recursive: true });
-  writeFileSync(safe.markerPath, "not-json");
-  const outside = root(); mkdirSync(outside, { recursive: true });
-  const link = layout(base, "2222222222222222"); mkdirSync(path.dirname(link.targetDir), { recursive: true }); symlinkSync(outside, link.targetDir);
-  const plan = { candidates: [
-    { id: "bad", dir: safe.targetDir, bytes: 1 },
-    { id: "link", dir: link.targetDir, bytes: 1 },
-    { id: "root", dir: base, bytes: 1 },
-  ] };
-  const result = applyCachePrune({ plan, cacheRoot: base, dryRun: false });
-  assert.deepEqual(result.removedIds, []);
-  assert.equal(existsSync(safe.targetDir), true);
-  assert.equal(lstatSync(link.targetDir).isSymbolicLink(), true);
-});
-
-test("entry creation rejects a symlinked cache ancestor before writing outside the cache root", () => {
-  const parent = root(); const outside = root(); mkdirSync(parent, { recursive: true }); mkdirSync(outside, { recursive: true });
-  symlinkSync(outside, path.join(parent, "cache"));
-  const unsafe = resolveCacheLayout({ cacheRoot: path.join(parent, "cache"), platform: "mac", architecture: "aarch64", app: "fixture", fingerprint: "3333333333333333", kind: "release" });
-  assert.throws(() => ensureCacheEntry({ layout: unsafe }), /symlink|unsafe/i);
-  assert.equal(existsSync(path.join(outside, "targets")), false);
-});
-
-test("prune takes the global GC lock and blocks a racing lease before deletion", () => {
-  const base = root(); const entry = layout(base, "4444444444444444"); ensureCacheEntry({ layout: entry }); writeFileSync(path.join(entry.targetDir, "payload"), "x");
-  const plan = { cacheRoot: base, candidates: [{ id: entry.id, dir: entry.targetDir, bytes: 1 }] };
-  assert.throws(() => applyCachePrune({ plan, cacheRoot: base, dryRun: false, beforeDelete: () => acquireCacheLease({ layout: entry }) }), /global GC lock active/);
-  assert.equal(existsSync(entry.targetDir), true);
-  assert.equal(existsSync(path.join(base, "gc", "gc.lock.json")), false);
-});
-
-test("a real child-process lease acquired after planning excludes its entry from prune", async () => {
-  const base = root(); const entry = layout(base, "5555555555555555"); ensureCacheEntry({ layout: entry }); writeFileSync(path.join(entry.targetDir, "payload"), "x");
-  const plan = { cacheRoot: base, candidates: [{ id: entry.id, dir: entry.targetDir, bytes: 1 }] };
-  const moduleUrl = new URL("./cache-policy.mjs", import.meta.url).href;
-  const child = spawn(process.execPath, ["--input-type=module", "--eval", `import { resolveCacheLayout, acquireCacheLease } from ${JSON.stringify(moduleUrl)}; const l=resolveCacheLayout({cacheRoot:process.argv[1],platform:'mac',architecture:'aarch64',app:'fixture',fingerprint:'5555555555555555',kind:'release'}); const lease=acquireCacheLease({layout:l}); console.log('ready'); setTimeout(()=>lease.release(),500);`, base], { stdio: ["ignore", "pipe", "pipe"] });
-  await once(child.stdout, "data");
-  const result = applyCachePrune({ plan, cacheRoot: base, dryRun: false });
-  assert.deepEqual(result.removedIds, []);
-  assert.equal(existsSync(entry.targetDir), true);
-  await once(child, "exit");
-});
-
-test("write-volume inspection deduplicates same devices and enforces both hard floors", () => {
-  const statfs = (dir) => ({ bsize: 1024, bavail: dir.includes("cache") ? 20 : 30, dev: dir.includes("same") ? 1 : dir.includes("cache") ? 2 : 3 });
-  const same = inspectWriteVolumes({ repoRoot: "/same/repo", vaultRoot: "/same/vault", cacheRoot: "/same/cache", statfs });
-  assert.equal(same.length, 1);
-  const distinct = inspectWriteVolumes({ repoRoot: "/repo", vaultRoot: "/repo", cacheRoot: "/cache", statfs });
-  assert.equal(distinct.length, 2);
-  assert.throws(() => assertWriteVolumeFloors({ volumes: distinct, policy: { hardFreeBytes: 25 * 1024 }, configuredRepoMinimumBytes: 25 * 1024 }), /cache|repo/i);
-});

package/cargo-guard.test.mjs

@@ -1,195 +0,0 @@
-import assert from "node:assert/strict";
-import path from "node:path";
-import test from "node:test";
-
-import { assertComputePolicyAllowsCargo, cargoCacheEnvironment, cargoProjectRoot, cargoSubcommand, checkHookInput, computePolicyPath, resolveRealCargo, resolveRealRustc, runCargoGuard, shellRunsCargoTest, shouldGuardCargo } from "./cargo-guard.mjs";
-
-test("compute policy path ignores XDG_CONFIG_HOME regardless of value", () => {
-  assert.equal(
-    computePolicyPath({ platform: "linux", env: { XDG_CONFIG_HOME: "/one/path" }, home: "/home/u" }),
-    computePolicyPath({ platform: "linux", env: {}, home: "/home/u" }),
-  );
-  assert.equal(computePolicyPath({ platform: "linux", env: {}, home: "/home/u" }), path.join("/home/u/.config/rightsuite", "compute-policy.json"));
-});
-
-test("Cargo guard serializes compiling commands but bypasses inspection and formatting", () => {
-  for (const args of [["build"], ["test"], ["check"], ["clippy"], ["nextest", "run"], ["clean"], ["+stable", "bench"]]) {
-    assert.equal(shouldGuardCargo(args), true, args.join(" "));
-  }
-  for (const args of [["fmt", "--check"], ["metadata"], ["tree"], ["fetch"], ["--version"], []]) {
-    assert.equal(shouldGuardCargo(args), false, args.join(" "));
-  }
-  assert.equal(cargoSubcommand(["+stable", "test"]), "test");
-  assert.equal(shouldGuardCargo(["--color", "always", "fmt"]), false);
-  assert.equal(shouldGuardCargo(["--config", "net.git-fetch-with-cli=true", "check"]), true);
-  assert.equal(shouldGuardCargo(["-Z", "unstable-options", "fmt"]), false);
-});
-
-test("global policy denies Cargo test before Cargo resolution", async () => {
-  const policy = { exists: () => true, read: () => '{"schemaVersion":1,"cargoTest":"deny"}', env: {} };
-  assert.throws(() => assertComputePolicyAllowsCargo(["test", "-p", "app"], policy), /denied by global/);
-  assert.doesNotThrow(() => assertComputePolicyAllowsCargo(["check"], policy));
-  let resolved = false;
-  await assert.rejects(runCargoGuard(["test"], {
-    env: { RIGHTSUITE_COMPUTE_POLICY: "/policy.json" },
-    policyOptions: { exists: () => true, read: () => '{"schemaVersion":1,"cargoTest":"deny"}' },
-    resolveCargo: () => { resolved = true; return "/real/cargo"; },
-  }), /denied by global/);
-  assert.equal(resolved, false);
-});
-
-test("Bash policy detects direct, absolute, rustup and nested Cargo tests only", () => {
-  for (const command of ["cargo test -p app", "cd app && /toolchain/bin/cargo +stable test", "rustup run stable cargo test", "bash -c 'cargo test'"]) {
-    assert.equal(shellRunsCargoTest(command), true, command);
-  }
-  for (const command of ["cargo check", "rg 'cargo test' docs", "echo cargo test", "cargo fmt --check"]) {
-    assert.equal(shellRunsCargoTest(command), false, command);
-  }
-  assert.throws(() => checkHookInput(JSON.stringify({ tool_input: { command: "cargo test" } }), {
-    exists: () => true, read: () => '{"schemaVersion":1,"cargoTest":"deny"}', env: {},
-  }), /denied by global/);
-});
-
-test("Cargo guard resolves real Cargo through rustup or explicit override", () => {
-  assert.equal(resolveRealCargo({ env: { RIGHTSUITE_REAL_CARGO: "/opt/toolchain/cargo" } }), path.resolve("/opt/toolchain/cargo"));
-  const calls = [];
-  const cargo = resolveRealCargo({ env: {}, run: (command, args) => { calls.push([command, args]); return { status: 0, stdout: "/real/cargo\n" }; } });
-  assert.equal(cargo, path.resolve("/real/cargo"));
-  assert.deepEqual(calls[0][1], ["which", "cargo"]);
-  assert.equal(resolveRealRustc({ env: { RIGHTSUITE_REAL_RUSTC: "/opt/toolchain/rustc" } }), path.resolve("/opt/toolchain/rustc"));
-  assert.equal(resolveRealRustc({ env: {}, run: () => ({ status: 0, stdout: "/real/rustc\n" }) }), path.resolve("/real/rustc"));
-});
-
-function cacheEnv(overrides = {}) {
-  return { ...(process.platform === "win32" ? { LOCALAPPDATA: "C:\\Users\\test\\AppData\\Local" } : { RIGHT_RELEASE_CACHE_ROOT: "/tmp/rightkit-release-cache" }), ...overrides };
-}
-
-test("Cargo guard injects project-keyed target and sccache directories", async () => {
-  let guarded;
-  await runCargoGuard(["build"], {
-    env: cacheEnv(), resolveCargo: () => "/real/cargo", resolveRustc: () => "/real/rustc",
-    runHeavy: async (_args, config) => { guarded = config.env; return 0; },
-  });
-  assert.match(guarded.CARGO_TARGET_DIR, /dev-targets[/\\][^/\\]+-[a-f0-9]{12}$/);
-  assert.match(guarded.SCCACHE_DIR, /[/\\]sccache$/);
-  assert.equal(guarded.RUSTC_WRAPPER, "sccache");
-});
-
-test("Cargo guard rejects cache escapes and alternate compiler wrappers", async () => {
-  const run = (args, overrides) => runCargoGuard(args, {
-    env: cacheEnv(overrides), resolveCargo: () => "/real/cargo", resolveRustc: () => "/real/rustc",
-    runHeavy: async () => 0,
-  });
-  await assert.rejects(run(["build"], { CARGO_TARGET_DIR: path.resolve("outside-target") }), /CARGO_TARGET_DIR/);
-  await assert.rejects(run(["build"], { SCCACHE_DIR: path.resolve("outside-sccache") }), /SCCACHE_DIR/);
-  await assert.rejects(run(["build", `--target-dir=${path.resolve("outside-flag")}`]), /--target-dir/);
-  await assert.rejects(run(["build"], { RUSTC_WRAPPER: "rustc-wrapper" }), /RUSTC_WRAPPER/);
-});
-
-test("Cargo guard hands the whole invocation to the broker on a managed host", async () => {
-  const calls = [];
-  let resolvedReal = false;
-  const options = {
-    env: { TEST: "1" },
-    policyOptions: { exists: () => false },
-    isBrokerHost: () => true,
-    resolveShim: () => "/managed/agent-bin/cargo",
-    resolveCargo: () => { resolvedReal = true; return "/real/cargo"; },
-    resolveRustc: () => { resolvedReal = true; return "/real/rustc"; },
-    runHeavy: async () => { throw new Error("must not run heavy on a broker host"); },
-    runLight: async (command, args) => { calls.push([command, args]); return 0; },
-  };
-  // A guarded command (build) and a light command (--version) both delegate to
-  // the broker shim verbatim, and the real-toolchain resolver is never touched.
-  assert.equal(await runCargoGuard(["build", "--release"], options), 0);
-  assert.equal(await runCargoGuard(["--version"], options), 0);
-  assert.deepEqual(calls, [["/managed/agent-bin/cargo", ["build", "--release"]], ["/managed/agent-bin/cargo", ["--version"]]]);
-  assert.equal(resolvedReal, false);
-});
-
-test("Cargo guard falls back to real resolution when a broker signal has no shim", async () => {
-  const calls = [];
-  await runCargoGuard(["build"], {
-    env: cacheEnv(), isBrokerHost: () => true, resolveShim: () => null,
-    resolveCargo: () => "/real/cargo", resolveRustc: () => "/real/rustc",
-    runHeavy: async (args) => { calls.push(args); return 0; },
-  });
-  assert.deepEqual(calls[0].slice(0, 2), ["--", "/real/cargo"]);
-});
-
-test("Cargo guard routes heavy and light commands without recursion", async () => {
-  const calls = [];
-  const options = {
-    env: { TEST: "1", ...cacheEnv() },
-    policyOptions: { exists: () => false },
-    resolveCargo: () => "/real/cargo",
-    resolveRustc: () => "/real/rustc",
-    runHeavy: async (args, config) => { calls.push(["heavy", args, config.env]); return 0; },
-    runLight: async (command, args, env) => { calls.push(["light", command, args, env]); return 0; },
-  };
-  assert.equal(await runCargoGuard(["test"], options), 0);
-  assert.equal(await runCargoGuard(["fmt", "--check"], options), 0);
-  assert.deepEqual(calls[0].slice(0, 2), ["heavy", ["--", "/real/cargo", "test"]]);
-  const cacheRoot = cacheEnv().RIGHT_RELEASE_CACHE_ROOT ?? path.join(cacheEnv().LOCALAPPDATA, "RightSuite", "Cache", "release");
-  assert.equal(calls[0][2].CARGO_TARGET_DIR.startsWith(path.join(path.resolve(cacheRoot), "dev-targets") + path.sep), true);
-  assert.equal(calls[0][2].RUSTC_WRAPPER, "sccache");
-  assert.deepEqual(calls[1], ["light", "/real/cargo", ["fmt", "--check"], options.env]);
-});
-
-test("Cargo guard forces target and compiler caches for each project", () => {
-  const existing = new Set(["/repo/Cargo.toml", "/repo/crate/Cargo.toml"]);
-  assert.equal(cargoProjectRoot(["test"], { cwd: "/repo/crate", platform: "mac", exists: (file) => existing.has(file) }), "/repo");
-  const env = cargoCacheEnvironment(["test"], {
-    cwd: "/repo/crate", platform: "mac", exists: (file) => existing.has(file),
-    env: { RIGHT_RELEASE_CACHE_ROOT: "/cache" },
-  });
-  assert.match(env.CARGO_TARGET_DIR, /^\/cache\/dev-targets\/repo-[a-f0-9]{12}$/);
-  assert.equal(env.RUSTC_WRAPPER, "sccache");
-  assert.equal(env.SCCACHE_DIR, "/cache/sccache");
-  assert.equal(env.RIGHTSUITE_CARGO_CACHE_GUARD, "1");
-});
-
-test("Cargo guard rejects cache bypasses and permits RightKit-owned cache paths", () => {
-  const base = { cwd: "/repo", platform: "mac", exists: () => false };
-  assert.throws(() => cargoCacheEnvironment(["test"], { ...base, env: { RIGHT_RELEASE_CACHE_ROOT: "/cache", CARGO_TARGET_DIR: "/tmp/target" } }), /CARGO_TARGET_DIR must stay inside/);
-  assert.throws(() => cargoCacheEnvironment(["test", "--target-dir", "/tmp/target"], { ...base, env: { RIGHT_RELEASE_CACHE_ROOT: "/cache" } }), /--target-dir must stay inside/);
-  assert.throws(() => cargoCacheEnvironment(["test"], { ...base, env: { RIGHT_RELEASE_CACHE_ROOT: "/cache", RUSTC_WRAPPER: "rustc-wrapper" } }), /must be sccache/);
-  const env = cargoCacheEnvironment(["test", "--target-dir=/cache/test-targets/app"], {
-    ...base,
-    env: { RIGHT_RELEASE_CACHE_ROOT: "/cache", CARGO_TARGET_DIR: "/cache/test-targets/app", SCCACHE_DIR: "/cache/sccache", RUSTC_WRAPPER: "/usr/bin/sccache" },
-  });
-  assert.equal(env.CARGO_TARGET_DIR, "/cache/test-targets/app");
-});
-
-test("Cargo guard passes a broker-owned CARGO_TARGET_DIR through instead of rejecting it", () => {
-  const base = { cwd: "/repo", platform: "mac", exists: () => false };
-  // Outside the shared cache root, which would be rejected on a non-broker host
-  // (see the previous test) — but the broker owns this value, not Cache V2.
-  const env = cargoCacheEnvironment(["test"], {
-    ...base,
-    env: { RIGHT_RELEASE_CACHE_ROOT: "/cache", RIGHTKIT_BUILD_BROKER_SOCKET: "/managed/broker.sock", CARGO_TARGET_DIR: "/broker/workspace/target" },
-  });
-  assert.equal(env.CARGO_TARGET_DIR, "/broker/workspace/target");
-
-  // Same for an explicit --target-dir outside the cache root.
-  const explicit = cargoCacheEnvironment(["test", "--target-dir", "/broker/workspace/target"], {
-    ...base,
-    env: { RIGHT_RELEASE_CACHE_ROOT: "/cache", RIGHTKIT_BUILD_BROKER_SOCKET: "/managed/broker.sock" },
-  });
-  assert.doesNotThrow(() => explicit);
-
-  // Non-broker host: unchanged, still rejects the cache bypass.
-  assert.throws(
-    () => cargoCacheEnvironment(["test"], { ...base, env: { RIGHT_RELEASE_CACHE_ROOT: "/cache", CARGO_TARGET_DIR: "/tmp/target" } }),
-    /CARGO_TARGET_DIR must stay inside/,
-  );
-});
-
-test("Cargo guard derives native Windows cache paths", () => {
-  const env = cargoCacheEnvironment(["build"], {
-    cwd: "D:\\Claude\\citadel", platform: "win", exists: (file) => file === "D:\\Claude\\citadel\\Cargo.toml",
-    env: { LOCALAPPDATA: "C:\\Users\\test\\AppData\\Local" },
-  });
-  assert.match(env.CARGO_TARGET_DIR, /^C:\\Users\\test\\AppData\\Local\\RightSuite\\Cache\\release\\dev-targets\\citadel-[a-f0-9]{12}$/);
-  assert.equal(env.SCCACHE_DIR, "C:\\Users\\test\\AppData\\Local\\RightSuite\\Cache\\release\\sccache");
-});

package/cargo-target.test.mjs

@@ -1,82 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { spawnSync } from "node:child_process";
-import test from "node:test";
-import { fileURLToPath } from "node:url";
-
-import { resolveTargetRoot } from "./cargo-target.mjs";
-
-const here = path.dirname(fileURLToPath(import.meta.url));
-const cli = path.join(here, "cargo-target.mjs");
-
-function fakeCargo() {
-  const bin = mkdtempSync(path.join(os.tmpdir(), "rightkit-fake-cargo-"));
-  return {
-    bin,
-    execFileSync(_command, args) {
-      const manifest = args.at(-1);
-      if (manifest.includes("fail-manifest")) throw new Error("boom");
-      if (manifest.includes("bad-target-manifest")) return '{"target_directory":"relative/target"}';
-      return JSON.stringify({ target_directory: path.join(bin, "target") });
-    },
-  };
-}
-
-test("resolveTargetRoot returns the absolute target_directory Cargo metadata reports", () => {
-  const { bin, execFileSync } = fakeCargo();
-  const manifest = path.join(mkdtempSync(path.join(os.tmpdir(), "rightkit-cargo-target-fixture-")), "Cargo.toml");
-  const result = resolveTargetRoot(manifest, { execFileSync });
-  assert.equal(result, path.resolve(path.join(bin, "target")));
-});
-
-test("resolveTargetRoot fails closed, naming the manifest, when target_directory is not absolute", () => {
-  const { execFileSync } = fakeCargo();
-  const manifest = path.join(mkdtempSync(path.join(os.tmpdir(), "rightkit-cargo-target-fixture-")), "bad-target-manifest-Cargo.toml");
-  assert.throws(
-    () => resolveTargetRoot(manifest, { execFileSync }),
-    new RegExp(`metadata for .*bad-target-manifest-Cargo\\.toml did not report an absolute target_directory`),
-  );
-});
-
-test("resolveTargetRoot fails closed, naming the manifest, when the metadata command exits non-zero", () => {
-  const { execFileSync } = fakeCargo();
-  const manifest = path.join(mkdtempSync(path.join(os.tmpdir(), "rightkit-cargo-target-fixture-")), "fail-manifest-Cargo.toml");
-  assert.throws(
-    () => resolveTargetRoot(manifest, { execFileSync }),
-    new RegExp(`metadata failed for .*fail-manifest-Cargo\\.toml`),
-  );
-});
-
-test("resolveTargetRoot throws when no manifest path is given", () => {
-  assert.throws(() => resolveTargetRoot(), /resolveTargetRoot requires a Cargo.toml manifest path/);
-  assert.throws(() => resolveTargetRoot(""), /resolveTargetRoot requires a Cargo.toml manifest path/);
-});
-
-test("CLI mode writes only the resolved path to stdout on success", () => {
-  const manifestDir = mkdtempSync(path.join(os.tmpdir(), "rightkit-cargo-target-fixture-"));
-  const manifest = path.join(manifestDir, "Cargo.toml");
-  mkdirSync(path.join(manifestDir, "src"));
-  writeFileSync(path.join(manifestDir, "src", "lib.rs"), "");
-  writeFileSync(manifest, "[package]\nname = \"fixture\"\nversion = \"0.0.0\"\n");
-  const result = spawnSync(process.execPath, [cli, manifest], { encoding: "utf8" });
-  assert.equal(result.status, 0, result.stderr);
-  assert.equal(path.isAbsolute(result.stdout.trim()), true);
-});
-
-test("CLI mode writes a message to stderr and exits 1 on failure", () => {
-  const manifestDir = mkdtempSync(path.join(os.tmpdir(), "rightkit-cargo-target-fixture-"));
-  const manifest = path.join(manifestDir, "fail-manifest-Cargo.toml");
-  writeFileSync(manifest, "not valid toml");
-  const result = spawnSync(process.execPath, [cli, manifest], { encoding: "utf8" });
-  assert.equal(result.status, 1);
-  assert.equal(result.stdout, "");
-  assert.match(result.stderr, /metadata failed for .*fail-manifest-Cargo\.toml/);
-});
-
-test("CLI mode requires a manifest argument", () => {
-  const result = spawnSync(process.execPath, [cli], { encoding: "utf8" });
-  assert.equal(result.status, 1);
-  assert.match(result.stderr, /usage: cargo-target\.mjs/);
-});

package/create-mac-updater.test.mjs

@@ -1,14 +0,0 @@
-import assert from "node:assert/strict";
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import test from "node:test";
-
-const helper = fileURLToPath(new URL("./create-mac-updater.mjs", import.meta.url));
-
-test("documents the final signed-app to signed-updater sequence in dry-run mode", () => {
-  const result = spawnSync(process.execPath, [helper, "--app", "bundle/Test.app", "--output", "bundle/Test.app.tar.gz", "--dry-run"], { encoding: "utf8" });
-  assert.equal(result.status, 0, result.stderr);
-  assert.match(result.stdout, /COPYFILE_DISABLE=1 tar .*Test\.app\.tar\.gz.*Test\.app[\\/]Contents/);
-  assert.doesNotMatch(result.stdout, / Test\.app$/m);
-  assert.match(result.stdout, /tauri signer sign .*Test\.app\.tar\.gz/);
-});