@rightkit/release 0.2.158 → 0.2.160

package/disk-command.mjs

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
-import { existsSync, mkdirSync, realpathSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, unlinkSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { spawnSync } from "./background-process.mjs";
+import { compareVersions } from "./rightkit-sync.mjs";
 import {
-  DISK_EXIT_WARNING, applySweep, checkDisk, formatBytes, listOpenPaths, logEvent, planSweep, platformKey, readDiskPolicy,
+  DISK_EXIT_WARNING, applySweep, checkDisk, formatBytes, listOpenPaths, logEvent, planSweep, platformKey, purgeHoldings, readDiskPolicy,
 } from "./disk-policy.mjs";
 
 export const LAUNCHD_LABEL = "dev.rightkit.disk-hygiene";
@@ -54,8 +55,6 @@ function parse(rest) {
   return opts;
 }
 
-const CHECKOUT_FILE = fileURLToPath(import.meta.url);
-
 // A path inside any git checkout (a `.git` entry on an ancestor) is development code, never an installed package.
 export function insideGitCheckout(file, exists = existsSync) {
   let dir = path.dirname(file);
@@ -67,19 +66,62 @@ export function insideGitCheckout(file, exists = existsSync) {
   }
 }
 
-/** Installed @rightkit/release CLI for the Windows task: explicit --cli / RIGHT_RELEASE_INSTALLED_CLI, else the global
- * node_modules (`npm root -g`, `pnpm root -g`). A checkout, including the one running install, is refused. */
-export function resolveInstalledCli({ explicit, env = process.env, globalRoots = defaultGlobalRoots, exists = existsSync, checkoutFile = CHECKOUT_FILE } = {}) {
-  const rel = path.join("@rightkit", "release", "cli", "right-release.mjs");
-  const candidates = explicit || env.RIGHT_RELEASE_INSTALLED_CLI
-    ? [explicit || env.RIGHT_RELEASE_INSTALLED_CLI]
-    : globalRoots({ env }).map((root) => path.join(root, rel));
-  const checkoutCli = path.join(path.dirname(checkoutFile), "cli", "right-release.mjs");
+const CLI_TAIL = path.join("@rightkit", "release", "cli", "right-release.mjs");
+const SHIM_TARGET = /(%~dp0|%dp0%|\$basedir|\$PSScriptRoot)?([^\s"'%$=;~]*node_modules[\\/]@rightkit[\\/]release[\\/]cli[\\/]right-release\.mjs)/;
+
+/** Target `cli/right-release.mjs` behind the `right-release` bin on PATH: the realpath of the bin when it is the script
+ * itself, otherwise the path a pnpm/npm shim (.cmd, .ps1 or sh script) names, resolved against the shim's directory. */
+export function cliFromPathBin({ env = process.env, exists = existsSync, readFile = (f) => readFileSync(f, "utf8") } = {}) {
+  const found = [];
+  for (const dir of String(env.PATH ?? env.Path ?? "").split(path.delimiter).filter(Boolean)) {
+    for (const name of ["right-release", "right-release.cmd", "right-release.ps1", "right-release.mjs"]) {
+      const bin = path.join(dir, name);
+      if (!exists(bin)) continue;
+      let real = bin;
+      try { real = realpathSync(bin); } catch { /* keep lexical */ }
+      if (real.endsWith(path.join("cli", "right-release.mjs"))) { found.push(real); continue; }
+      try {
+        const m = SHIM_TARGET.exec(readFile(real));
+        if (m) found.push(path.resolve(dir, (m[1] ? m[2].replace(/^[\\/]+/, "") : m[2]).split(/[\\/]/).join(path.sep)));
+      } catch { /* unreadable shim */ }
+    }
+  }
+  return found;
+}
+
+const versionOf = (cli, readFile) => {
+  try { return JSON.parse(readFile(path.join(path.dirname(cli), "..", "package.json"))).version; } catch { return "0.0.0"; }
+};
+
+/** Global-root candidates: `<root>/@rightkit/release/...` (npm, pnpm <= 10) and `<root>/<hash>/node_modules/@rightkit/release/...`
+ * (pnpm 11 global layout), highest installed version first. */
+export function cliFromGlobalRoots(roots, { exists = existsSync, readdir = (d) => readdirSync(d), readFile = (f) => readFileSync(f, "utf8") } = {}) {
+  const found = [];
+  for (const root of roots) {
+    found.push(path.join(root, CLI_TAIL));
+    let names = [];
+    try { names = readdir(root); } catch { /* root absent */ }
+    for (const name of names) found.push(path.join(root, name, "node_modules", CLI_TAIL));
+  }
+  return found.filter((f) => exists(f))
+    .map((f) => ({ f, v: versionOf(f, readFile) }))
+    .sort((x, y) => { try { return compareVersions(y.v, x.v); } catch { return 0; } })
+    .map((x) => x.f);
+}
+
+/** Installed @rightkit/release CLI for the Windows task: explicit --cli / RIGHT_RELEASE_INSTALLED_CLI, else the target of the
+ * `right-release` bin on PATH, else the global package roots (`npm root -g`, `pnpm root -g`, hashed pnpm 11 layout included).
+ * Only a candidate inside a git checkout is refused; the installed package may itself run install. */
+export function resolveInstalledCli({ explicit, env = process.env, globalRoots = defaultGlobalRoots, exists = existsSync, readFile, readdir, pathBin = cliFromPathBin } = {}) {
+  const fixed = explicit || env.RIGHT_RELEASE_INSTALLED_CLI;
+  const candidates = fixed
+    ? [fixed]
+    : [...pathBin({ env, exists, ...(readFile ? { readFile } : {}) }), ...cliFromGlobalRoots(globalRoots({ env }), { exists, ...(readFile ? { readFile } : {}), ...(readdir ? { readdir } : {}) })];
   for (const candidate of candidates) {
     if (!exists(candidate)) continue;
     let real = candidate;
     try { real = realpathSync(candidate); } catch { /* keep lexical */ }
-    if (real === checkoutCli || insideGitCheckout(real, exists)) continue;
+    if (insideGitCheckout(real, exists)) continue;
     return candidate;
   }
   throw new Error("disk schedule install needs the installed @rightkit/release (not a checkout): install it globally or pass --cli <path to the installed cli/right-release.mjs>");
@@ -183,6 +225,11 @@ export async function runDiskCommand(args = process.argv.slice(2), { env = proce
     out({ ...p, applied }, renderSweep(p, applied));
     return { exitCode: applied.results.some((r) => !r.ok) ? 1 : 0, plan: p, applied };
   }
+  if (command === "purge") {
+    const purged = purgeHoldings({ policy, platform, env, days: opts.days, dryRun: opts.dryRun, ...deps.purge });
+    out(purged, `${opts.dryRun ? "Dry run: would purge" : "Purged"} ${purged.results.length} holding dir(s)${purged.results.map((r) => `\n  ${formatBytes(r.bytes).padStart(9)}  ${r.path}${r.ok ? "" : `  FAILED: ${r.error}`}`).join("")}`);
+    return { exitCode: purged.results.some((r) => !r.ok) ? 1 : 0, purged };
+  }
   if (command === "run") {
     const before = check();
     stdout(renderCheck(before));
@@ -190,13 +237,15 @@ export async function runDiskCommand(args = process.argv.slice(2), { env = proce
     stdout(renderSweep(p));
     const applied = applySweep({ plan: p, policy, platform, ...deps.apply });
     stdout(`moved ${formatBytes(applied.movedBytes)} (${applied.results.filter((r) => r.ok).length}/${applied.results.length})`);
+    const purged = purgeHoldings({ policy, platform, env, ...deps.purge });
+    stdout(`purged ${purged.results.filter((r) => r.ok).length} holding dir(s), ${formatBytes(purged.purgedBytes)}`);
     const after = check();
     const warn = after.warn;
     logEvent(logFile, { event: warn ? "disk.floor.warn" : "disk.run.ok", warnings: after.warnings, freeBytes: after.floor.freeBytes, movedBytes: applied.movedBytes });
     if (warn) stdout(`WARNING: ${after.warnings.join("; ")}`);
-    return { exitCode: warn ? DISK_EXIT_WARNING : 0, before, after, applied };
+    return { exitCode: warn ? DISK_EXIT_WARNING : 0, before, after, applied, purged };
   }
-  throw new Error("disk usage: check|sweep [--dry-run|--delete] [--days N]|run|schedule install|uninstall|status  [--json]");
+  throw new Error("disk usage: check|sweep [--dry-run|--delete] [--days N]|purge [--dry-run] [--days N]|run|schedule install|uninstall|status  [--json]");
 }
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {

package/disk-policy.json

@@ -5,6 +5,11 @@
     "mac": {"path": "/System/Volumes/Data", "label": "Mac internal", "warnFreeBytes": 42949672960},
     "win": {"path": "D:\\", "label": "Dell D:", "warnFreeBytes": 429496729600, "warnFreePercent": 10}
   },
+  "holdingDays": 3,
+  "holding": {
+    "mac": [{"prefix": "/", "path": "~/.rightkit-swept"}],
+    "win": [{"prefix": "C:\\", "path": "${LOCALAPPDATA}\\Orthic Labs\\.rightkit-swept"}]
+  },
   "heavyVolume": {
     "mac": "/Volumes/D/claude/tmp/swept",
     "win": "D:\\claude\\tmp\\swept"
@@ -44,5 +49,5 @@
     {"id": "leftover-legion-final", "platform": "mac", "path": "/Volumes/D/claude/legion-final-*", "capBytes": 1073741824, "action": "sweep", "unit": "self"},
     {"id": "leftover-pulse-bak", "platform": "win", "path": "${LOCALAPPDATA}\\Programs\\Pulse.bak-*", "capBytes": 1073741824, "action": "sweep", "unit": "self"}
   ],
-  "protectedSegments": ["Application Support", "Keychains", "Keychain", "HeardRightNext", "Credentials", ".ssh", ".rightkit-managed"]
+  "protectedSegments": ["Application Support", "Keychains", "Keychain", "HeardRightNext", "Credentials", ".ssh", ".rightkit-managed", ".rightkit-swept"]
 }

package/disk-policy.mjs

@@ -1,4 +1,4 @@
-import { closeSync, cpSync, existsSync, lstatSync, mkdirSync, opendirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, statfsSync, appendFileSync } from "node:fs";
+import { closeSync, cpSync, existsSync, lstatSync, mkdirSync, opendirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, statfsSync, appendFileSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -224,9 +224,68 @@ export function planSweep({ policy, platform = process.platform, env = process.e
   return { schema: 1, platform: key, staleDays, candidates, skipped, totalBytes: candidates.reduce((s, c) => s + c.bytes, 0) };
 }
 
-export function sweptDestination({ policy, platform = process.platform, date = new Date() }) {
+export const HOLDING_DIR = ".rightkit-swept";
+export const HOLDING_MARKER = ".rightkit-release-holding";
+const DATE_DIR = /^\d{4}-\d{2}-\d{2}$/;
+
+// Device id of a path, or of its nearest existing ancestor (null when none can be read).
+export function deviceOf(target) {
+  let cur = target;
+  for (;;) {
+    try { return statSync(cur).dev; } catch {
+      const up = path.dirname(cur);
+      if (up === cur) return null;
+      cur = up;
+    }
+  }
+}
+
+// Highest ancestor of `target` still on the same device: the mount point (or drive root) holding it.
+export function volumeRoot(target) {
+  const dev = deviceOf(target);
+  let cur = target;
+  for (;;) {
+    const up = path.dirname(cur);
+    if (up === cur || deviceOf(up) !== dev) return cur;
+    cur = up;
+  }
+}
+
+const isUnder = (candidate, prefix, win) => {
+  const norm = (v) => (win ? v.toLowerCase() : v);
+  const c = norm(candidate); const p = norm(prefix);
+  const withSep = p.endsWith(path.sep) || p.endsWith("/") || p.endsWith("\\") ? p : p + path.sep;
+  return c === p || c.startsWith(withSep);
+};
+
+// Candidate holding bases for an item, best first: policy per-volume rules (longest prefix), then the item's own volume root.
+export function holdingBases(candidate, { policy, platform = process.platform, env = process.env, home = os.homedir() } = {}) {
   const key = platformKey(platform);
-  return path.join(policy.heavyVolume[key], date.toISOString().slice(0, 10));
+  const out = [];
+  const rules = (policy.holding?.[key] ?? []).flatMap((r) => {
+    try { return [{ prefix: expandPolicyPath(r.prefix, { env, home }), path: expandPolicyPath(r.path, { env, home }) }]; } catch { return []; }
+  }).filter((r) => isUnder(candidate, r.prefix, key === "win")).sort((a, b) => b.prefix.length - a.prefix.length);
+  for (const r of rules) out.push(r.path);
+  out.push(path.join(volumeRoot(path.dirname(candidate)), HOLDING_DIR));
+  return out;
+}
+
+// Create (and mark) today's holding dir on the item's own volume; null when no holding dir on that volume is possible.
+export function pickHolding(candidate, { policy, platform = process.platform, env = process.env, home = os.homedir(), date = new Date(), bases } = {}) {
+  const dev = deviceOf(path.dirname(candidate));
+  for (const base of bases ?? holdingBases(candidate, { policy, platform, env, home })) {
+    try {
+      if (deviceOf(base) !== dev) continue; // checked before creating anything: a base on another volume would free nothing
+      mkdirSync(base, { recursive: true });
+      if (deviceOf(base) !== dev || lstatSync(base).isSymbolicLink()) continue;
+      const marker = path.join(base, HOLDING_MARKER);
+      if (!existsSync(marker)) writeFileSync(marker, "created by right-release disk; date-named children are purged after the retention window\n");
+      const dir = path.join(base, date.toISOString().slice(0, 10));
+      mkdirSync(dir, { recursive: true });
+      return dir;
+    } catch { /* try the next base */ }
+  }
+  return null;
 }
 
 export function moveEntry(source, destination) {
@@ -248,19 +307,27 @@ export function logEvent(logFile, event) {
   } catch { /* logging must never fail the sweep */ }
 }
 
-export function applySweep({ plan, policy, platform = process.platform, deleteMode = false, date = new Date(), move = moveEntry, remove = (p) => rmSync(p, { recursive: true, force: true }) }) {
-  const destRoot = sweptDestination({ policy, platform, date });
+export function applySweep({ plan, policy, platform = process.platform, deleteMode = false, date = new Date(), env = process.env, home = os.homedir(), move = moveEntry, pick = pickHolding, remove = (p) => rmSync(p, { recursive: true, force: true }) }) {
   const logFile = path.join(policy.heavyVolume[platformKey(platform)], "disk-hygiene.jsonl");
   const results = [];
   for (const c of plan.candidates) {
-    const rel = path.join(c.writer, path.basename(c.path));
-    let destination = path.join(destRoot, rel);
-    if (existsSync(destination)) destination = `${destination}.${date.getTime()}`;
     try {
       // Re-verify at apply time: still the planned unit, not a symlink, still inside its root.
       if (!c.root || lstatSync(c.path).isSymbolicLink() || !isInsideRoot(c.path, c.root)) throw new Error("refused: path is not a sweepable unit inside its target root");
-      if (deleteMode) { remove(c.path); results.push({ ...c, action: "delete", ok: true }); logEvent(logFile, { event: "disk.sweep.delete", ...c }); }
-      else { const how = move(c.path, destination); results.push({ ...c, action: "move", destination, how, ok: true }); logEvent(logFile, { event: "disk.sweep.move", ...c, destination, how }); }
+      if (deleteMode) { remove(c.path); results.push({ ...c, action: "delete", ok: true }); logEvent(logFile, { event: "disk.sweep.delete", ...c }); continue; }
+      // An item stays on its own volume: moving it elsewhere frees nothing on the volume that is short of space.
+      const holding = pick(c.path, { policy, platform, env, home, date });
+      if (!holding) {
+        remove(c.path);
+        results.push({ ...c, action: "delete", how: "no-holding-on-volume", ok: true });
+        logEvent(logFile, { event: "disk.sweep.delete", reason: "no holding dir possible on the item's volume", ...c });
+        continue;
+      }
+      let destination = path.join(holding, c.writer, path.basename(c.path));
+      if (existsSync(destination)) destination = `${destination}.${date.getTime()}`;
+      const how = move(c.path, destination);
+      results.push({ ...c, action: "move", destination, how, ok: true });
+      logEvent(logFile, { event: "disk.sweep.move", ...c, destination, how });
     } catch (error) {
       results.push({ ...c, action: deleteMode ? "delete" : "move", ok: false, error: error.message });
       logEvent(logFile, { event: "disk.sweep.error", ...c, error: error.message });
@@ -268,3 +335,48 @@ export function applySweep({ plan, policy, platform = process.platform, deleteMo
   }
   return { logFile, results, movedBytes: results.filter((r) => r.ok).reduce((s, r) => s + r.bytes, 0) };
 }
+
+// Holding bases that may exist: policy rule paths, each drive root (Windows) or /Volumes/* and the legacy heavy dir (Mac).
+export function knownHoldingBases({ policy, platform = process.platform, env = process.env, home = os.homedir() } = {}) {
+  const key = platformKey(platform);
+  const bases = new Set();
+  for (const r of policy.holding?.[key] ?? []) { try { bases.add(expandPolicyPath(r.path, { env, home })); } catch { /* unset variable */ } }
+  if (key === "win") for (const letter of "ABCDEFGHIJKLMNOPQRSTUVWXYZ") { const root = `${letter}:\\`; if (existsSync(root)) bases.add(path.join(root, HOLDING_DIR)); }
+  else { bases.add(path.join(path.sep, HOLDING_DIR)); try { for (const v of readdirSync("/Volumes")) bases.add(path.join("/Volumes", v, HOLDING_DIR)); } catch { /* no /Volumes */ } }
+  return [...bases];
+}
+
+/** Remove date-named holding dirs older than `days`. Only dirs this tool created: the base must carry the holding marker
+ * (or, for the legacy heavy dir, the tool's own log), the child must be a real directory named YYYY-MM-DD, never a symlink. */
+export function purgeHoldings({ policy, platform = process.platform, env = process.env, home = os.homedir(), now = Date.now(), days = policy.holdingDays ?? 3, dryRun = false, bases, remove = (p) => rmSync(p, { recursive: true, force: true }), size = walkSize } = {}) {
+  const key = platformKey(platform);
+  const legacy = policy.heavyVolume?.[key];
+  const list = bases ?? [...knownHoldingBases({ policy, platform, env, home }), ...(legacy ? [legacy] : [])];
+  const logFile = legacy ? path.join(legacy, "disk-hygiene.jsonl") : null;
+  const cutoff = now - days * 86400_000;
+  const results = [];
+  for (const base of new Set(list)) {
+    let st;
+    try { st = lstatSync(base); } catch { continue; }
+    if (!st.isDirectory() || st.isSymbolicLink()) continue;
+    const owned = existsSync(path.join(base, HOLDING_MARKER)) || (base === legacy && existsSync(path.join(base, "disk-hygiene.jsonl")));
+    if (!owned) continue;
+    let names = [];
+    try { names = readdirSync(base); } catch { continue; }
+    for (const name of names) {
+      if (!DATE_DIR.test(name)) continue;
+      const dir = path.join(base, name);
+      let dst;
+      try { dst = lstatSync(dir); } catch { continue; }
+      if (!dst.isDirectory() || dst.isSymbolicLink()) continue;
+      const stamp = Date.parse(`${name}T00:00:00Z`);
+      if (!Number.isFinite(stamp) || stamp + 86400_000 > cutoff) continue; // the whole day must be older than the window
+      const bytes = size(dir);
+      try {
+        if (!dryRun) { remove(dir); if (logFile) logEvent(logFile, { event: "disk.purge", path: dir, bytes }); }
+        results.push({ path: dir, bytes, ok: true, dryRun });
+      } catch (error) { results.push({ path: dir, bytes, ok: false, error: error.message }); }
+    }
+  }
+  return { results, purgedBytes: results.filter((r) => r.ok && !r.dryRun).reduce((a, r) => a + r.bytes, 0) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rightkit/release",
-  "version": "0.2.158",
+  "version": "0.2.160",
   "description": "Portable release CLI/SDK with fail-closed public GitHub Releases and private R2 + RightApps distribution.",
   "license": "MIT OR Apache-2.0",
   "type": "module",

package/rightkit-versions.json

@@ -15,7 +15,7 @@
   "stagedNpm": {
     "@rightkit/app-update": "0.2.5",
     "@rightkit/ax": "0.3.2",
-    "@rightkit/ci": "0.2.43",
+    "@rightkit/ci": "0.2.44",
     "@rightkit/doc-render": "0.1.6",
     "@rightkit/hooks": "0.1.2",
     "@rightkit/i18n": "0.1.0",
@@ -31,7 +31,7 @@
     "@rightkit/qa": "0.4.8",
     "@rightkit/qa-chrome": "0.1.6",
     "@rightkit/react-shell": "0.6.4",
-    "@rightkit/release": "0.2.158",
+    "@rightkit/release": "0.2.160",
     "@rightkit/settings-ui": "0.4.4",
     "@rightkit/tauri": "0.2.1",
     "@rightkit/tauri-shell": "0.1.1",
@@ -199,7 +199,9 @@
       "0.2.150",
       "0.2.151",
       "0.2.155",
-      "0.2.156"
+      "0.2.156",
+      "0.2.158",
+      "0.2.159"
     ],
     "@rightkit/qa": [
       "0.1.0",
@@ -326,6 +328,9 @@
     ],
     "@rightkit/shell": [
       "0.1.0"
+    ],
+    "@rightkit/ci": [
+      "0.2.43"
     ]
   },
   "cargo": {
@@ -488,7 +493,7 @@
       "@rightkit/app-shell": "0.6.2",
       "@rightkit/app-update": "0.2.5",
       "@rightkit/ax": "0.3.2",
-      "@rightkit/ci": "0.2.43",
+      "@rightkit/ci": "0.2.44",
       "@rightkit/doc-render": "0.1.6",
       "@rightkit/git": "0.2.42",
       "@rightkit/hooks": "0.1.2",
@@ -505,7 +510,7 @@
       "@rightkit/qa": "0.4.8",
       "@rightkit/qa-chrome": "0.1.6",
       "@rightkit/react-shell": "0.6.4",
-      "@rightkit/release": "0.2.156",
+      "@rightkit/release": "0.2.159",
       "@rightkit/settings-ui": "0.4.4",
       "@rightkit/shell": "0.1.1",
       "@rightkit/tauri": "0.2.1",