@rightkit/release 0.2.33 → 0.2.35

package/build-release.mjs

@@ -20,7 +20,7 @@ import {
 import path from "node:path";
 import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { cacheFingerprint, releaseEnvironment, resolveReleaseLayout, runBuildStateMachine } from "./release-state.mjs";
+import { cacheFingerprint, commandOutputPortable, releaseEnvironment, resolveReleaseLayout, runBuildStateMachine, watchProgress } from "./release-state.mjs";
 
 const TOOL_ROOT = path.dirname(fileURLToPath(import.meta.url));
 const WORKER = path.join(TOOL_ROOT, "release.mjs");
@@ -145,7 +145,13 @@ try {
         await runProgress(config.packageManager ?? "pnpm", ["install", "--frozen-lockfile"], appRoot, env, cacheTarget);
       },
       build: async () => {
-        await runProgress(process.execPath, [WORKER, "--config", worktreeConfigPath, "--platform", platform, "--no-upload"], appRoot, env, env.CARGO_TARGET_DIR);
+        await runProgress(
+          process.execPath,
+          [WORKER, "--config", worktreeConfigPath, "--platform", platform, "--no-upload"],
+          appRoot,
+          env,
+          [env.CARGO_TARGET_DIR, path.join(appRoot, ".cache")],
+        );
         checkpoint(stateRoot, "build_complete");
         checkpoint(stateRoot, "signed");
         checkpoint(stateRoot, "hardened");
@@ -269,22 +275,25 @@ async function runProgress(cmd, runArgs, cwd, env, watchDir) {
   const inactivityMs = Number(process.env.RIGHT_RELEASE_STALL_MS ?? 10 * 60 * 1000);
   const absoluteMs = Number(process.env.RIGHT_RELEASE_ABSOLUTE_MS ?? 90 * 60 * 1000);
   let lastProgress = Date.now();
-  let lastMtime = newestMtime(watchDir);
+  const watchDirs = Array.isArray(watchDir) ? watchDir : [watchDir];
+  let lastMtime = Math.max(...watchDirs.map(newestMtime));
   const started = Date.now();
   await new Promise((resolve, reject) => {
     child = spawn(cmd, runArgs, { cwd, env, stdio: ["inherit", "pipe", "pipe"], windowsHide: true, shell: process.platform === "win32" });
+    const closeWatchers = watchProgress(watchDirs, () => { lastProgress = Date.now(); });
     for (const [stream, output] of [[child.stdout, process.stdout], [child.stderr, process.stderr]]) {
       stream.on("data", (chunk) => { lastProgress = Date.now(); output.write(chunk); });
     }
     const monitor = setInterval(() => {
-      const mtime = newestMtime(watchDir);
+      const mtime = Math.max(...watchDirs.map(newestMtime));
       if (mtime > lastMtime) { lastMtime = mtime; lastProgress = Date.now(); }
       if (Date.now() - started > absoluteMs) stop(`absolute limit exceeded (${Math.round(absoluteMs / 60000)}m)`);
       else if (Date.now() - lastProgress > inactivityMs) stop(`no output or file progress for ${Math.round(inactivityMs / 60000)}m`);
     }, Math.min(30_000, Math.max(250, Math.floor(inactivityMs / 4))));
-    const stop = (reason) => { clearInterval(monitor); killTree(child.pid); reject(new Error(`release step stalled: ${reason}`)); };
-    child.once("error", (error) => { clearInterval(monitor); reject(error); });
-    child.once("exit", (code) => { clearInterval(monitor); child = null; code === 0 ? resolve() : reject(new Error(`${cmd} exited ${code}`)); });
+    const cleanup = () => { clearInterval(monitor); closeWatchers(); };
+    const stop = (reason) => { cleanup(); killTree(child.pid); reject(new Error(`release step stalled: ${reason}`)); };
+    child.once("error", (error) => { cleanup(); reject(error); });
+    child.once("exit", (code) => { cleanup(); child = null; code === 0 ? resolve() : reject(new Error(`${cmd} exited ${code}`)); });
   });
 }
 
@@ -342,9 +351,11 @@ function commandExists(name) {
 }
 
 function commandOutput(cmd, runArgs) {
-  const result = spawnSync(cmd, runArgs, { encoding: "utf8", windowsHide: true });
-  if (result.status !== 0) fail(`required command failed: ${cmd} ${runArgs.join(" ")}`);
-  return result.stdout.trim();
+  try {
+    return commandOutputPortable(cmd, runArgs);
+  } catch (error) {
+    fail(`required command failed: ${error.message}`);
+  }
 }
 
 function git(cwd, runArgs) {

package/package.json

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

package/release-state.mjs

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, watch } from "node:fs";
 import path from "node:path";
 
 export function cacheFingerprint({ cargoLockSha256, rustc, target, features = [] }) {
@@ -23,6 +24,41 @@ export function resolveReleaseLayout({ repoRoot, configPath }) {
   };
 }
 
+export function commandOutputPortable(cmd, args, { cwd, env = process.env } = {}) {
+  const windows = process.platform === "win32";
+  if (windows && ![cmd, ...args].every((value) => /^[A-Za-z0-9._:/@+=-]+$/.test(value))) {
+    throw new Error("unsafe Windows command token");
+  }
+  const executable = windows ? (env.ComSpec || env.COMSPEC || "cmd.exe") : cmd;
+  const executableArgs = windows ? ["/d", "/s", "/c", [cmd, ...args].join(" ")] : args;
+  const result = spawnSync(executable, executableArgs, {
+    cwd,
+    env,
+    encoding: "utf8",
+    windowsHide: true,
+  });
+  if (result.status !== 0) {
+    const detail = result.error?.message || result.stderr?.trim() || `exit ${result.status}`;
+    throw new Error(`${cmd} ${args.join(" ")} failed: ${detail}`);
+  }
+  return result.stdout.trim();
+}
+
+export function watchProgress(paths, onProgress) {
+  const watchers = [];
+  for (const candidate of paths) {
+    if (!candidate || !existsSync(candidate)) continue;
+    try {
+      watchers.push(watch(candidate, { recursive: true }, onProgress));
+    } catch {
+      try { watchers.push(watch(candidate, onProgress)); } catch { /* output still counts as progress */ }
+    }
+  }
+  return () => {
+    for (const watcher of watchers) watcher.close();
+  };
+}
+
 export function releaseEnvironment({ root, platform, cacheKey, kind = "release" }) {
   if (kind !== "release" && kind !== "test") throw new Error(`invalid target kind: ${kind}`);
   const targetKind = kind === "release" ? "cargo-target" : "test-target";

package/release-state.test.mjs

@@ -1,12 +1,15 @@
 import assert from "node:assert/strict";
 import { createHash } from "node:crypto";
 import { mkdtempSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
 
 import {
   cacheFingerprint,
+  commandOutputPortable,
+  watchProgress,
   resolveReleaseLayout,
   releaseEnvironment,
   runBuildStateMachine,
@@ -14,6 +17,28 @@ import {
   verifySealedRelease,
 } from "./release-state.mjs";
 
+test("progress watcher observes writes in nested Cargo target directories", async () => {
+  const root = mkdtempSync(path.join(os.tmpdir(), "right-release-watch-"));
+  const nested = path.join(root, "release", "build", "openssl");
+  mkdirSync(nested, { recursive: true });
+  let resolveProgress;
+  const progress = new Promise((resolve) => { resolveProgress = resolve; });
+  const close = watchProgress([root], resolveProgress);
+  try {
+    await writeFile(path.join(nested, "object.lib"), "progress");
+    await Promise.race([
+      progress,
+      new Promise((_, reject) => setTimeout(() => reject(new Error("nested progress event missing")), 2_000)),
+    ]);
+  } finally {
+    close();
+  }
+});
+
+test("portable command capture resolves Windows command shims", { skip: process.platform !== "win32" }, () => {
+  assert.match(commandOutputPortable("pnpm", ["--version"]), /^11\.12\.0$/);
+});
+
 test("nested app configs keep the vault at repo root and build from the app root", () => {
   const layout = resolveReleaseLayout({
     repoRoot: "D:/suite/heardright",

package/right-suite-contract.test.mjs

@@ -317,7 +317,7 @@ test("Cargo version contract rejects staged versions that mismatch canonical man
 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.33");
+  assert.equal(versions.npm["@rightkit/release"], "0.2.35");
   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.33",
+    "@rightkit/release": "0.2.35",
     "@rightkit/tauri": "0.1.0",
     "@rightkit/updates": "0.2.3"
   },