@rainy-updates/cli 0.5.6 → 0.6.0

package/dist/commands/audit/targets.js

@@ -1,4 +1,3 @@
-import { promises as fs } from "node:fs";
 import path from "node:path";
 const LOCKFILE_PRIORITY = [
     "package-lock.json",
@@ -86,13 +85,9 @@ async function findNearestLockfiles(rootCwd, startDir) {
     while (true) {
         for (const fileName of LOCKFILE_PRIORITY) {
             const candidate = path.join(current, fileName);
-            try {
-                await fs.access(candidate);
+            if (await fileExists(candidate)) {
                 found.push(candidate);
             }
-            catch {
-                // ignore missing
-            }
         }
         if (current === rootCwd)
             break;
@@ -115,9 +110,6 @@ async function resolveFromPackageLock(lockfilePath, packageDir, packageName) {
         if (version)
             return version;
     }
-    if (!relDir) {
-        return parsed.dependencies?.[packageName]?.version ?? null;
-    }
     return parsed.dependencies?.[packageName]?.version ?? null;
 }
 async function resolveFromPnpmLock(lockfilePath, packageDir, packageName) {
@@ -149,8 +141,8 @@ async function resolveFromBunLock(lockfilePath, packageDir, packageName) {
 async function readPackageLock(lockfilePath) {
     let promise = packageLockCache.get(lockfilePath);
     if (!promise) {
-        promise = fs
-            .readFile(lockfilePath, "utf8")
+        promise = Bun.file(lockfilePath)
+            .text()
             .then((content) => JSON.parse(content));
         packageLockCache.set(lockfilePath, promise);
     }
@@ -159,7 +151,7 @@ async function readPackageLock(lockfilePath) {
 async function readPnpmLock(lockfilePath) {
     let promise = pnpmLockCache.get(lockfilePath);
     if (!promise) {
-        promise = fs.readFile(lockfilePath, "utf8").then(parsePnpmLock);
+        promise = Bun.file(lockfilePath).text().then(parsePnpmLock);
         pnpmLockCache.set(lockfilePath, promise);
     }
     return await promise;
@@ -167,7 +159,7 @@ async function readPnpmLock(lockfilePath) {
 async function readBunLock(lockfilePath) {
     let promise = bunLockCache.get(lockfilePath);
     if (!promise) {
-        promise = fs.readFile(lockfilePath, "utf8").then(parseBunLock);
+        promise = Bun.file(lockfilePath).text().then(parseBunLock);
         bunLockCache.set(lockfilePath, promise);
     }
     return await promise;
@@ -312,3 +304,11 @@ function normalizePnpmVersion(value) {
 function trimYamlKey(value) {
     return value.trim().replace(/^['"]|['"]$/g, "");
 }
+async function fileExists(filePath) {
+    try {
+        return await Bun.file(filePath).exists();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/commands/bisect/oracle.js

@@ -1,5 +1,5 @@
-import { spawn } from "node:child_process";
 import path from "node:path";
+import { detectPackageManager, resolvePackageManager } from "../../pm/detect.js";
 /**
  * The "oracle" for bisect: installs a specific version of a package
  * into the project's node_modules (via the shell), then runs --cmd.
@@ -11,7 +11,9 @@ export async function bisectOracle(packageName, version, options) {
         process.stderr.write(`[bisect:dry-run] Would test ${packageName}@${version}\n`);
         return "skip";
     }
-    const installResult = await runShell(`npm install --no-save ${packageName}@${version}`, options.cwd);
+    const detected = await detectPackageManager(options.cwd);
+    const packageManager = resolvePackageManager("auto", detected, "bun");
+    const installResult = await runShell(buildInstallCommand(packageManager, packageName, version), options.cwd);
     if (installResult !== 0) {
         process.stderr.write(`[bisect] Failed to install ${packageName}@${version}, skipping.\n`);
         return "skip";
@@ -22,15 +24,30 @@ export async function bisectOracle(packageName, version, options) {
     process.stderr.write(`[bisect] ${packageName}@${version} → ${outcome}\n`);
     return outcome;
 }
-function runShell(command, cwd) {
-    return new Promise((resolve) => {
-        const [bin, ...args] = command.split(" ");
-        const child = spawn(bin, args, {
+async function runShell(command, cwd) {
+    try {
+        const shellCmd = process.env.SHELL || "sh";
+        const proc = Bun.spawn([shellCmd, "-c", command], {
             cwd: path.resolve(cwd),
-            shell: true,
-            stdio: "pipe",
+            stdout: "pipe",
+            stderr: "pipe",
         });
-        child.on("close", (code) => resolve(code ?? 1));
-        child.on("error", () => resolve(1));
-    });
+        return await proc.exited;
+    }
+    catch {
+        return 1;
+    }
+}
+function buildInstallCommand(packageManager, packageName, version) {
+    const spec = `${packageName}@${version}`;
+    switch (packageManager) {
+        case "bun":
+            return `bun add --exact --no-save ${spec}`;
+        case "pnpm":
+            return `pnpm add --save-exact --no-save ${spec}`;
+        case "yarn":
+            return `npm install --no-save --save-exact ${spec}`;
+        default:
+            return `npm install --no-save --save-exact ${spec}`;
+    }
 }

package/dist/commands/bisect/parser.js

@@ -1,11 +1,11 @@
 import path from "node:path";
-import process from "node:process";
+import { getRuntimeCwd } from "../../utils/runtime.js";
 export function parseBisectArgs(args) {
     const options = {
-        cwd: process.cwd(),
+        cwd: getRuntimeCwd(),
         packageName: "",
         versionRange: undefined,
-        testCommand: "npm test",
+        testCommand: "",
         concurrency: 4,
         registryTimeoutMs: 8000,
         cacheTtlSeconds: 3600,

package/dist/commands/bisect/runner.js

@@ -1,26 +1,33 @@
+import { detectPackageManager, resolvePackageManager } from "../../pm/detect.js";
 import { fetchBisectVersions, bisectVersions } from "./engine.js";
 /**
  * Entry point for the `bisect` command. Lazy-loaded by cli.ts.
  * Fully isolated: does NOT import anything from core/options.ts.
  */
 export async function runBisect(options) {
-    process.stderr.write(`\n[bisect] Fetching available versions for ${options.packageName}...\n`);
-    const versions = await fetchBisectVersions(options);
+    const detected = await detectPackageManager(options.cwd);
+    const runtimeOptions = {
+        ...options,
+        testCommand: options.testCommand ||
+            `${resolvePackageManager("auto", detected, "bun")} test`,
+    };
+    process.stderr.write(`\n[bisect] Fetching available versions for ${runtimeOptions.packageName}...\n`);
+    const versions = await fetchBisectVersions(runtimeOptions);
     if (versions.length === 0) {
-        throw new Error(`No versions found for package "${options.packageName}".`);
+        throw new Error(`No versions found for package "${runtimeOptions.packageName}".`);
     }
     process.stderr.write(`[bisect] Found ${versions.length} versions. Starting binary search...\n`);
-    if (options.versionRange) {
-        process.stderr.write(`[bisect] Range: ${options.versionRange}\n`);
+    if (runtimeOptions.versionRange) {
+        process.stderr.write(`[bisect] Range: ${runtimeOptions.versionRange}\n`);
     }
-    const result = await bisectVersions(versions, options);
+    const result = await bisectVersions(versions, runtimeOptions);
     if (result.breakingVersion) {
-        process.stdout.write(`\n✖ Break introduced in ${options.packageName}@${result.breakingVersion}\n` +
+        process.stdout.write(`\n✖ Break introduced in ${runtimeOptions.packageName}@${result.breakingVersion}\n` +
             `  Last good version: ${result.lastGoodVersion ?? "none"}\n` +
             `  Tested: ${result.totalVersionsTested} versions in ${result.iterations} iterations\n`);
     }
     else {
-        process.stdout.write(`\n✔ No breaking version found for ${options.packageName} (all versions passed).\n` +
+        process.stdout.write(`\n✔ No breaking version found for ${runtimeOptions.packageName} (all versions passed).\n` +
             `  Tested: ${result.totalVersionsTested} versions\n`);
     }
     return result;

package/dist/commands/changelog/fetcher.js

@@ -1,12 +1,12 @@
-import os from "node:os";
+import { mkdir } from "node:fs/promises";
 import path from "node:path";
-import { promises as fs } from "node:fs";
+import { getCacheDir } from "../../utils/runtime-paths.js";
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
 class ChangelogCache {
     db = null;
     dbPath;
     constructor() {
-        const basePath = path.join(os.homedir(), ".cache", "rainy-updates");
+        const basePath = getCacheDir();
         this.dbPath = path.join(basePath, "cache.db");
     }
     async init() {
@@ -14,7 +14,7 @@ class ChangelogCache {
             return;
         try {
             if (typeof Bun !== "undefined") {
-                await fs.mkdir(path.dirname(this.dbPath), { recursive: true });
+                await mkdir(path.dirname(this.dbPath), { recursive: true });
                 const mod = await import("bun:sqlite");
                 this.db = new mod.Database(this.dbPath, { create: true });
                 this.db.exec(`
@@ -111,7 +111,7 @@ export async function fetchChangelog(packageName, repositoryUrl) {
             if (contentsRes.ok) {
                 const fileContent = await contentsRes.json();
                 if (fileContent.content && fileContent.encoding === "base64") {
-                    content = Buffer.from(fileContent.content, "base64").toString("utf-8");
+                    content = decodeBase64Utf8(fileContent.content);
                 }
             }
         }
@@ -128,3 +128,9 @@ export async function fetchChangelog(packageName, repositoryUrl) {
         return null;
     }
 }
+function decodeBase64Utf8(value) {
+    const normalized = value.replace(/\s+/g, "");
+    const binary = atob(normalized);
+    const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+    return new TextDecoder().decode(bytes);
+}

package/dist/commands/dashboard/parser.js

@@ -1,7 +1,10 @@
+import path from "node:path";
 export function parseDashboardArgs(args) {
     const options = {
         cwd: process.cwd(),
         target: "latest",
+        filter: undefined,
+        reject: undefined,
         includeKinds: [
             "dependencies",
             "devDependencies",
@@ -12,19 +15,44 @@ export function parseDashboardArgs(args) {
         ci: false,
         format: "table",
         workspace: false,
+        jsonFile: undefined,
+        githubOutputFile: undefined,
+        sarifFile: undefined,
         concurrency: 16,
         registryTimeoutMs: 8000,
         registryRetries: 3,
         offline: false,
         stream: false,
+        policyFile: undefined,
+        prReportFile: undefined,
+        failOn: "none",
+        maxUpdates: undefined,
+        fixPr: false,
+        fixBranch: "chore/rainy-updates",
+        fixCommitMessage: undefined,
+        fixDryRun: false,
+        fixPrNoCheckout: false,
+        fixPrBatchSize: undefined,
+        noPrReport: false,
         logLevel: "info",
         groupBy: "none",
+        groupMax: undefined,
+        cooldownDays: undefined,
+        prLimit: undefined,
         onlyChanged: false,
         ciProfile: "minimal",
         lockfileMode: "preserve",
         interactive: true,
         showImpact: false,
         showHomepage: true,
+        mode: "review",
+        focus: "all",
+        applySelected: false,
+        decisionPlanFile: undefined,
+        verify: "none",
+        testCommand: undefined,
+        verificationReportFile: undefined,
+        ciGate: "check",
     };
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
@@ -44,16 +72,90 @@ export function parseDashboardArgs(args) {
         if (arg === "--view") {
             throw new Error("Missing value for --view");
         }
+        if (arg === "--mode" && nextArg) {
+            if (nextArg === "check" ||
+                nextArg === "review" ||
+                nextArg === "upgrade") {
+                options.mode = nextArg;
+                i++;
+                continue;
+            }
+            throw new Error(`Invalid --mode: ${nextArg}`);
+        }
+        if (arg === "--mode") {
+            throw new Error("Missing value for --mode");
+        }
+        if (arg === "--focus" && nextArg) {
+            if (nextArg === "all" ||
+                nextArg === "security" ||
+                nextArg === "risk" ||
+                nextArg === "major" ||
+                nextArg === "blocked" ||
+                nextArg === "workspace") {
+                options.focus = nextArg;
+                i++;
+                continue;
+            }
+            throw new Error(`Invalid --focus: ${nextArg}`);
+        }
+        if (arg === "--focus") {
+            throw new Error("Missing value for --focus");
+        }
+        if (arg === "--apply-selected") {
+            options.applySelected = true;
+            continue;
+        }
+        if (arg === "--verify" && nextArg) {
+            if (nextArg === "none" ||
+                nextArg === "install" ||
+                nextArg === "test" ||
+                nextArg === "install,test") {
+                options.verify = nextArg;
+                i++;
+                continue;
+            }
+            throw new Error(`Invalid --verify: ${nextArg}`);
+        }
+        if (arg === "--verify") {
+            throw new Error("Missing value for --verify");
+        }
+        if (arg === "--test-command" && nextArg) {
+            options.testCommand = nextArg;
+            i++;
+            continue;
+        }
+        if (arg === "--test-command") {
+            throw new Error("Missing value for --test-command");
+        }
+        if (arg === "--verification-report-file" && nextArg) {
+            options.verificationReportFile = path.resolve(options.cwd, nextArg);
+            i++;
+            continue;
+        }
+        if (arg === "--verification-report-file") {
+            throw new Error("Missing value for --verification-report-file");
+        }
+        if (arg === "--plan-file" && nextArg) {
+            options.decisionPlanFile = path.resolve(options.cwd, nextArg);
+            i++;
+            continue;
+        }
+        if (arg === "--plan-file") {
+            throw new Error("Missing value for --plan-file");
+        }
         // Pass through common workspace / cwd args
         if (arg === "--workspace") {
             options.workspace = true;
             continue;
         }
         if (arg === "--cwd" && nextArg) {
-            options.cwd = nextArg;
+            options.cwd = path.resolve(nextArg);
             i++;
             continue;
         }
+        if (arg.startsWith("-")) {
+            throw new Error(`Unknown dashboard option: ${arg}`);
+        }
     }
     return options;
 }

package/dist/commands/dashboard/runner.d.ts

@@ -1,2 +1,2 @@
-import type { DashboardOptions, DashboardResult } from "../../types/index.js";
-export declare function runDashboard(options: DashboardOptions): Promise<DashboardResult>;
+import type { DashboardOptions, DashboardResult, ReviewResult } from "../../types/index.js";
+export declare function runDashboard(options: DashboardOptions, prebuiltReview?: ReviewResult): Promise<DashboardResult>;

package/dist/commands/dashboard/runner.js

@@ -1,47 +1,77 @@
-import React from "react";
-import { render } from "ink";
-import { loadConfig } from "../../config/loader.js";
-import { DashboardTUI } from "../../ui/dashboard/DashboardTUI.js";
-// We'll need to load initial state or data before or during the render
-import { check } from "../../core/check.js";
-export async function runDashboard(options) {
-    // Load configuration
-    const resolvedConfig = await loadConfig(options.cwd);
-    // Create an initial check result. In a real scenario, this could run
-    // progressively in the TUI, but for simplicity we fetch initial data first.
-    const checkResult = await check({
+import { createDecisionPlan, defaultDecisionPlanPath, filterReviewItemsByFocus, writeDecisionPlan, } from "../../core/decision-plan.js";
+import { buildReviewResult, renderReviewResult } from "../../core/review-model.js";
+import { applySelectedUpdates } from "../../core/upgrade.js";
+import { runVerification } from "../../core/verification.js";
+import { runTui } from "../../ui/tui.js";
+import { writeStderr, writeStdout } from "../../utils/runtime.js";
+export async function runDashboard(options, prebuiltReview) {
+    const review = prebuiltReview ?? (await buildReviewResult({
         ...options,
-        // We do not want `check` to exit or log heavily here, the UI will take over.
-        logLevel: "error",
-    });
-    // Render the interactive Ink Dashboard
-    const { waitUntilExit } = render(React.createElement(DashboardTUI, {
-        options,
-        initialResult: checkResult,
+        interactive: false,
     }));
-    await waitUntilExit();
-    const finalStore = await import("../../ui/dashboard/store.js");
-    const finalState = finalStore.getStore()?.getState();
-    if (finalState?.shouldApply) {
-        process.stderr.write("[dashboard] Applying updates...\n");
-        const { applySelectedUpdates } = await import("../../core/upgrade.js");
-        const { detectPackageManager } = await import("../../pm/detect.js");
-        const { installDependencies } = await import("../../pm/install.js");
+    const visibleItems = filterReviewItemsByFocus(review.items, options.focus);
+    const selectedItems = await selectDashboardItems(options, visibleItems);
+    const decisionPlan = createDecisionPlan({
+        review,
+        selectedItems,
+        sourceCommand: "dashboard",
+        mode: options.mode,
+        focus: options.focus,
+    });
+    const decisionPlanFile = options.decisionPlanFile ?? defaultDecisionPlanPath(options.cwd);
+    await writeDecisionPlan(decisionPlanFile, decisionPlan);
+    review.decisionPlan = decisionPlan;
+    review.summary.decisionPlan = decisionPlanFile;
+    review.summary.interactiveSurface = "dashboard";
+    review.summary.queueFocus = options.focus;
+    review.summary.suggestedCommand =
+        options.mode === "upgrade" || options.applySelected
+            ? `rup upgrade --from-plan ${decisionPlanFile}`
+            : `rup upgrade --from-plan ${decisionPlanFile}`;
+    if ((options.mode === "upgrade" || options.applySelected) && selectedItems.length > 0) {
         await applySelectedUpdates({
             ...options,
-            install: false, // We handle installation explicitly below
+            install: false,
             packageManager: "auto",
-            sync: true,
-            lockfileMode: options.lockfileMode || "preserve",
-        }, finalState.updates);
-        // Install using the correct package manager if desired
-        const detected = await detectPackageManager(options.cwd);
-        await installDependencies(options.cwd, "auto", detected);
-        process.stderr.write("[dashboard] Successfully applied updates and installed dependencies.\n");
+            sync: options.workspace,
+        }, selectedItems.map((item) => item.update));
+        if (options.verify !== "none") {
+            const verification = await runVerification({
+                cwd: options.cwd,
+                verify: options.verify,
+                testCommand: options.testCommand,
+                verificationReportFile: options.verificationReportFile,
+                packageManager: "auto",
+            });
+            if (!verification.passed) {
+                review.errors.push(...verification.checks
+                    .filter((check) => !check.passed)
+                    .map((check) => `Verification failed for ${check.name}: ${check.error ?? check.command}`));
+            }
+        }
     }
+    writeStdout(renderReviewResult({
+        ...review,
+        items: selectedItems,
+        updates: selectedItems.map((item) => item.update),
+    }) + "\n");
+    writeStderr(`[dashboard] decision plan written to ${decisionPlanFile}\n`);
     return {
         completed: true,
-        errors: [],
-        warnings: [],
+        errors: review.errors,
+        warnings: review.warnings,
+        selectedUpdates: selectedItems.length,
+        decisionPlanFile,
     };
 }
+async function selectDashboardItems(options, visibleItems) {
+    if (visibleItems.length === 0) {
+        return [];
+    }
+    return runTui(visibleItems, {
+        title: options.mode === "upgrade"
+            ? "Rainy Dashboard: Upgrade Queue"
+            : "Rainy Dashboard: Review Queue",
+        subtitle: `focus=${options.focus}  mode=${options.mode}  Enter confirms the selected decision set`,
+    });
+}

package/dist/commands/doctor/parser.js

@@ -1,8 +1,8 @@
 import path from "node:path";
-import process from "node:process";
+import { exitProcess, getRuntimeCwd, writeStdout, } from "../../utils/runtime.js";
 export function parseDoctorArgs(args) {
     const options = {
-        cwd: process.cwd(),
+        cwd: getRuntimeCwd(),
         target: "latest",
         filter: undefined,
         reject: undefined,
@@ -41,8 +41,14 @@ export function parseDoctorArgs(args) {
         interactive: false,
         showImpact: true,
         showHomepage: true,
+        decisionPlanFile: undefined,
+        verify: "none",
+        testCommand: undefined,
+        verificationReportFile: undefined,
+        ciGate: "check",
         verdictOnly: false,
         includeChangelog: false,
+        agentReport: false,
     };
     for (let i = 0; i < args.length; i += 1) {
         const current = args[i];
@@ -66,6 +72,10 @@ export function parseDoctorArgs(args) {
             options.includeChangelog = true;
             continue;
         }
+        if (current === "--agent-report") {
+            options.agentReport = true;
+            continue;
+        }
         if (current === "--json-file" && next) {
             options.jsonFile = path.resolve(options.cwd, next);
             i += 1;
@@ -74,8 +84,8 @@ export function parseDoctorArgs(args) {
         if (current === "--json-file")
             throw new Error("Missing value for --json-file");
         if (current === "--help" || current === "-h") {
-            process.stdout.write(DOCTOR_HELP);
-            process.exit(0);
+            writeStdout(DOCTOR_HELP);
+            exitProcess(0);
         }
         if (current.startsWith("-"))
             throw new Error(`Unknown doctor option: ${current}`);
@@ -92,6 +102,7 @@ Usage:
 Options:
   --verdict-only         Print the 3-line quick verdict without counts
   --include-changelog    Include release note summaries in the aggregated review data
+  --agent-report         Print a prompt-ready remediation report for coding agents
   --workspace            Scan all workspace packages
   --json-file <path>     Write JSON doctor report to file
   --cwd <path>

package/dist/commands/doctor/runner.js

@@ -1,11 +1,14 @@
-import process from "node:process";
-import { buildReviewResult, createDoctorResult, renderDoctorResult } from "../../core/review-model.js";
+import { buildReviewResult, createDoctorResult, renderDoctorAgentReport, renderDoctorResult, } from "../../core/review-model.js";
 import { stableStringify } from "../../utils/stable-json.js";
 import { writeFileAtomic } from "../../utils/io.js";
+import { writeStdout } from "../../utils/runtime.js";
 export async function runDoctor(options) {
     const review = await buildReviewResult(options);
     const doctor = createDoctorResult(review);
-    process.stdout.write(renderDoctorResult(doctor, options.verdictOnly) + "\n");
+    const output = options.agentReport
+        ? renderDoctorAgentReport(doctor)
+        : renderDoctorResult(doctor, options.verdictOnly);
+    writeStdout(output + "\n");
     if (options.jsonFile) {
         await writeFileAtomic(options.jsonFile, stableStringify(doctor, 2) + "\n");
     }

package/dist/commands/ga/parser.js

@@ -1,8 +1,8 @@
 import path from "node:path";
-import process from "node:process";
+import { exitProcess, getRuntimeCwd, writeStdout, } from "../../utils/runtime.js";
 export function parseGaArgs(args) {
     const options = {
-        cwd: process.cwd(),
+        cwd: getRuntimeCwd(),
         workspace: false,
         jsonFile: undefined,
     };
@@ -28,8 +28,8 @@ export function parseGaArgs(args) {
         if (current === "--json-file")
             throw new Error("Missing value for --json-file");
         if (current === "--help" || current === "-h") {
-            process.stdout.write(GA_HELP);
-            process.exit(0);
+            writeStdout(GA_HELP);
+            exitProcess(0);
         }
         if (current.startsWith("-"))
             throw new Error(`Unknown ga option: ${current}`);

package/dist/commands/ga/runner.js

@@ -1,11 +1,10 @@
-import { promises as fs } from "node:fs";
 import path from "node:path";
-import process from "node:process";
 import { VersionCache } from "../../cache/cache.js";
 import { detectPackageManager } from "../../pm/detect.js";
 import { discoverPackageDirs } from "../../workspace/discover.js";
 import { stableStringify } from "../../utils/stable-json.js";
 import { writeFileAtomic } from "../../utils/io.js";
+import { writeStdout } from "../../utils/runtime.js";
 export async function runGa(options) {
     const packageManager = await detectPackageManager(options.cwd);
     const packageDirs = await discoverPackageDirs(options.cwd, options.workspace);
@@ -15,8 +14,8 @@ export async function runGa(options) {
         name: "package-manager",
         status: packageManager === "unknown" ? "warn" : "pass",
         detail: packageManager === "unknown"
-            ? "No supported lockfile was detected. npm-compatible execution is still possible."
-            : `Detected package manager: ${packageManager}.`,
+            ? "No supported lockfile was detected. Rainy can still run, but runtime/package verification will fall back to generic defaults."
+            : `Detected package manager: ${packageManager}. Runtime and verification can align with this package ecosystem, including Bun.`,
     });
     checks.push({
         name: "workspace-discovery",
@@ -40,6 +39,14 @@ export async function runGa(options) {
             ? "Built CLI entrypoint exists in dist/bin/cli.js."
             : "Built CLI entrypoint is missing; run the build before publishing a release artifact.",
     });
+    const compiledBinaryExists = await fileExists(path.resolve(options.cwd, "dist/rup"));
+    checks.push({
+        name: "runtime-artifacts",
+        status: compiledBinaryExists ? "pass" : "warn",
+        detail: compiledBinaryExists
+            ? "Compiled Bun runtime artifact exists in dist/rup."
+            : "Compiled Bun runtime artifact is missing; run bun run build:exe before publishing Bun-first release artifacts.",
+    });
     checks.push({
         name: "benchmark-gates",
         status: (await fileExists(path.resolve(options.cwd, "scripts/perf-smoke.mjs"))) &&
@@ -68,7 +75,7 @@ export async function runGa(options) {
         warnings,
         errors,
     };
-    process.stdout.write(renderGaResult(result) + "\n");
+    writeStdout(renderGaResult(result) + "\n");
     if (options.jsonFile) {
         await writeFileAtomic(options.jsonFile, stableStringify(result, 2) + "\n");
     }
@@ -120,8 +127,7 @@ async function detectLockfile(cwd) {
 }
 async function fileExists(filePath) {
     try {
-        await fs.access(filePath);
-        return true;
+        return await Bun.file(filePath).exists();
     }
     catch {
         return false;

package/dist/commands/health/parser.js

@@ -1,8 +1,8 @@
 import path from "node:path";
-import process from "node:process";
+import { getRuntimeCwd } from "../../utils/runtime.js";
 export function parseHealthArgs(args) {
     const options = {
-        cwd: process.cwd(),
+        cwd: getRuntimeCwd(),
         workspace: false,
         staleDays: 365,
         includeDeprecated: true,