@rightkit/release 0.2.172 → 0.2.174

package/runtime-budgets.mjs

@@ -199,7 +199,7 @@ export function renderRuntimeBudgetBody(budget) {
     const host = `${m.host?.os}/${m.host?.arch}${m.host?.model ? ` (${m.host.model})` : ""}`;
     const scale = `${count(m.dataScale?.count)} ${m.dataScale?.unit} (${m.dataScale?.description})`;
     const app = m.scope === "installed" && m.app ? `, app ${m.app.name} ${m.app.version}` : "";
-    const observed = BUDGET_FIGURES.map((k) => `${FIGURE_LABEL[k]} ${m.observed?.[k] === undefined ? "n/a" : FORMAT[k](m.observed[k])}`).join(", ");
+    const observed = BUDGET_FIGURES.map((k) => `${FIGURE_LABEL[k]} ${m.observed?.[k] === undefined || m.observed?.[k] === null ? "n/a (not measurable on this host)" : FORMAT[k](m.observed[k])}`).join(", ");
     out.push(`- Measured: ${host}, ${budget.crate} ${m.crateVersion} at ${String(m.commit).slice(0, 12)}, ${scale}, ${m.scope}${app}, \`${m.command}\`, ${m.date}, evidence ${String(m.evidence?.sha256 ?? "none").slice(0, 12)}: ${observed}.`);
   }
   return out;
@@ -291,6 +291,10 @@ export function measurementStaleness(commit, crateDir, git = defaultGit, deps =
 
 // ---------------------------------------------------------------- bench evidence
 
+// Figures a host cannot measure by design. macOS has no per-process disk-operation count (rightkit-child-process
+// usage.rs: ru_inblock/ru_oublock stay 0 there), so disk_ops_per_s may be "unavailable" on darwin only.
+export const HOST_UNAVAILABLE_FIGURES = Object.freeze({ darwin: Object.freeze(["diskOpsPerSecond"]) });
+export const figureUnavailableOn = (os, key) => (HOST_UNAVAILABLE_FIGURES[os] ?? []).includes(key);
 const RESULT_NUMBERS = Object.freeze({ resident_bytes: "residentMemoryBytes", idle_cpu_percent: "idleCpuPercent", wakeups_per_s: "wakeupsPerSecond", disk_ops_per_s: "diskOpsPerSecond", scale_count: "scaleCount" });
 const RESULT_WORDS = Object.freeze(["crate", "version", "scale_unit"]);
 
@@ -312,7 +316,8 @@ export function parseBudgetResult(text) {
   for (const key of RESULT_WORDS) { if (!nonEmpty(fields[key])) problems.push(`missing field ${key}`); else value[key] = fields[key]; }
   for (const [key, name] of Object.entries(RESULT_NUMBERS)) {
     const n = Number(fields[key]);
-    if (fields[key] === undefined || fields[key] === "" || !Number.isFinite(n) || n < 0) problems.push(`field ${key} must be a non-negative number`);
+    if (fields[key] === "unavailable" && name !== "residentMemoryBytes" && name !== "scaleCount") value[name] = null;
+    else if (fields[key] === undefined || fields[key] === "" || !Number.isFinite(n) || n < 0) problems.push(`field ${key} must be a non-negative number`);
     else value[name] = n;
   }
   return problems.length ? { ok: false, problems } : { ok: true, problems: [], value };
@@ -412,6 +417,7 @@ function validateMeasurement(m, index) {
   }
   if (!nonEmpty(m.command)) problems.push(`${at} has no command`);
   for (const key of BUDGET_FIGURES) {
+    if (m.observed?.[key] === null && figureUnavailableOn(m.host?.os, key)) continue;
     if (!isNumber(m.observed?.[key]) || m.observed[key] < 0) problems.push(`${at} observed.${key} must be a non-negative number`);
   }
   if (isNumber(m.observed?.residentMemoryBytes) && m.observed.residentMemoryBytes === 0) {
@@ -507,12 +513,12 @@ export function evaluateRuntimeBudget({ crate, crateDir, version, evidence, requ
   }
   for (const { m, index } of counted) {
     for (const key of BUDGET_FIGURES) {
-      if (ceilings[key] !== undefined && m.observed[key] > ceilings[key]) {
+      if (ceilings[key] !== undefined && m.observed[key] !== null && m.observed[key] > ceilings[key]) {
         problems.push(`measurement[${index}] on ${m.host.os}/${m.host.arch} exceeds the ${FIGURE_LABEL[key]} ceiling: observed ${m.observed[key]} > ${ceilings[key]}`);
       }
     }
   }
-  const withinCeilings = (m) => BUDGET_FIGURES.every((key) => ceilings[key] !== undefined && m.observed[key] <= ceilings[key]);
+  const withinCeilings = (m) => BUDGET_FIGURES.every((key) => ceilings[key] !== undefined && (m.observed[key] === null ? figureUnavailableOn(m.host?.os, key) : m.observed[key] <= ceilings[key]));
   const atScale = (m) => requiredScale !== null && m.dataScale.unit === requiredScale.unit && m.dataScale.count >= requiredScale.minCount;
   const staleness = new Map();
   const stale = (m) => {
@@ -768,7 +774,7 @@ export function appRuntimeBudgetAdoptionCheck({ appRoot, app, version, cargoLock
       if (evidenceProblems.length) { problems.push(`${crate}: ${evidenceProblems.join("; ")}`); return false; }
       if (m.app.name !== app) { problems.push(`${crate}: measurement[${index}] is for app ${m.app.name}, not ${app}`); return false; }
       if (version && m.app.version !== version) { problems.push(`${crate}: measurement[${index}] was taken at ${app} ${m.app.version}, not the current ${version}`); return false; }
-      const over = BUDGET_FIGURES.filter((k) => m.observed[k] > ceilings[k]);
+      const over = BUDGET_FIGURES.filter((k) => m.observed[k] !== null && m.observed[k] > ceilings[k]);
       if (over.length) { problems.push(`${crate}: measurement[${index}] exceeds ${over.join(", ")}`); return false; }
       if (m.dataScale.unit !== requiredScale.unit || m.dataScale.count < requiredScale.minCount) { problems.push(`${crate}: measurement[${index}] is below the required scale ${requiredScale.minCount} ${requiredScale.unit}`); return false; }
       return true;
@@ -813,6 +819,9 @@ export function recordMeasurement({ crateDir, resultFile, scope, command, descri
   const v = parsed.value;
   if (v.crate !== pkg.name) throw new Error(`bench output is for ${v.crate}, crate is ${pkg.name}`);
   if (v.version !== pkg.version) throw new Error(`bench output is for version ${v.version}, crate is ${pkg.version}`);
+  for (const key of BUDGET_FIGURES) {
+    if (v[key] === null && !figureUnavailableOn(host.os, key)) throw new Error(`bench output rejected: ${key} is unavailable, which is allowed only where the host cannot measure it (${JSON.stringify(HOST_UNAVAILABLE_FIGURES)})`);
+  }
   if (!SCOPES.includes(scope)) throw new Error(`--scope must be one of ${SCOPES.join(", ")}`);
   if (scope === "installed" && !(nonEmpty(app?.name) && nonEmpty(app?.version))) throw new Error("--scope installed needs --app and --app-version");
   if (!nonEmpty(command)) throw new Error("--command (the exact bench command) is required");

package/stage-binary.mjs

@@ -9,7 +9,7 @@ import { resolveTargetRoot } from "./cargo-target.mjs";
  * The build broker writes Cargo output to per-generation folders (`<managed>/rightkit-build-control/ws/<hash>/g/<gen>/...`)
  * and `cargo-guard` uses a hashed `dev-targets/<project>-<hash>` folder. Those are build output only: their path is not
  * stable, so NOTHING may run from them. macOS ties privacy grants to the path an app runs from, so a dev or QA binary is
- * copied in place to `<root>/.rightkit-dev-bin/<triple-or-host>/<name>` (keeping `<name>.previous`) and run from there.
+ * copied in place to `<root>/.rightkit-dev-bin/<triple-or-host>/<name>` (replaced in place, no `.previous` kept) and run from there.
  */
 export const DEV_STAGE_DIRECTORY = ".rightkit-dev-bin";
 

package/stage-sidecar-command.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+// `right-release stage-sidecar [--config right-release.config.mjs] [--target <triple>] [--check] [--json]` (bogusyogi/rightkit#345):
+// stages the config's declarative `sidecars` into src-tauri/binaries with Tauri externalBin naming. `--check` validates
+// the manifest and prints the plan without building, downloading, copying or deleting anything (for template gates).
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { planSidecarStaging, resolveTargetTriple, stageSidecars } from "./stage-sidecar.mjs";
+
+export function parseStageSidecarArgs(argv) {
+  const opts = { config: "right-release.config.mjs", target: undefined, json: false, check: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--config" || arg === "--target") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} needs a value`);
+      opts[arg.slice(2)] = value;
+      i += 1;
+    } else if (arg === "--json") opts.json = true;
+    else if (arg === "--check") opts.check = true;
+    else throw new Error(`unknown stage-sidecar argument: ${arg}`);
+  }
+  return opts;
+}
+
+const NODE_ARCH = { x64: "x86_64", arm64: "aarch64" };
+const NODE_OS = { darwin: "apple-darwin", win32: "pc-windows-msvc", linux: "unknown-linux-gnu" };
+
+/** Host triple from Node alone (no subprocess), so `--check` stays free of effects. */
+export function nodeHostTriple(platform = process.platform, arch = process.arch) {
+  const cpu = NODE_ARCH[arch];
+  const system = NODE_OS[platform];
+  if (!cpu || !system) throw new Error(`cannot derive a target triple from ${platform}/${arch}; pass --target`);
+  return `${cpu}-${system}`;
+}
+
+/** Human-readable plan lines for `--check`. */
+export function formatSidecarPlan(plan) {
+  const lines = [`right-release stage-sidecar --check: target ${plan.target}, mode ${plan.mode}, stageDir ${plan.stageDir}${plan.wipeStageDir ? " (wipeStageDir)" : ""}`];
+  for (const entry of plan.entries) {
+    if (entry.skipped) lines.push(`  [${entry.index}] ${entry.kind}: skipped (platforms ${entry.platforms.join(",")})`);
+    else lines.push(`  [${entry.index}] ${entry.kind}: ${entry.outputs.join(", ")}${entry.externalBin ? " (externalBin)" : ""}${entry.clean ? " (clean)" : ""}${entry.url ? ` <- ${entry.url}` : ""}`);
+  }
+  if (plan.nestedBrokerRisk) lines.push("  warning: running inside an outer broker build; staging would fail with STAGE_SIDECAR_NESTED_BROKER (run stage-sidecar in recipe prepare, before the Tauri build)");
+  lines.push("right-release stage-sidecar --check: manifest is valid; nothing was staged");
+  return lines;
+}
+
+async function main() {
+  const opts = parseStageSidecarArgs(process.argv.slice(2));
+  const configPath = path.resolve(opts.config);
+  const appRoot = path.dirname(configPath);
+  const loaded = await import(pathToFileURL(configPath).href);
+  const config = loaded.default ?? loaded.config ?? loaded;
+  if (config?.sidecars === undefined) throw new Error(`${opts.config} declares no sidecars`);
+  if (opts.check) {
+    const target = opts.target ?? process.env.TAURI_ENV_TARGET_TRIPLE ?? nodeHostTriple();
+    const plan = planSidecarStaging({ manifest: config.sidecars, target });
+    if (opts.json) console.log(JSON.stringify(plan, null, 2));
+    else for (const line of formatSidecarPlan(plan)) console.log(line);
+    return;
+  }
+  const target = resolveTargetTriple({ target: opts.target, cwd: appRoot });
+  const result = await stageSidecars({ appRoot, manifest: config.sidecars, target });
+  if (opts.json) console.log(JSON.stringify(result, null, 2));
+  else {
+    for (const file of result.files ?? []) console.log(`right-release stage-sidecar: staged ${typeof file === "string" ? file : file.path ?? JSON.stringify(file)}`);
+    console.log(`right-release stage-sidecar: externalBin ${JSON.stringify(result.externalBinNames ?? [])}; receipt ${result.receiptPath}`);
+  }
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
+  main().catch((error) => { console.error(`right-release stage-sidecar: ${error.code ? `[${error.code}] ` : ""}${error.message}`); process.exitCode = 1; });
+}