braeburn 1.4.1 → 1.4.3

package/dist/commands/update.js

@@ -1,12 +1,27 @@
 import { collectVersions } from "../update/versionCollector.js";
 import { captureYesNo } from "../ui/prompt.js";
-import { buildScreen, createScreenRenderer } from "../ui/screen.js";
+import { buildScreen, buildScreenWithAnimationFrame, createScreenRenderer } from "../ui/screen.js";
 import { hideCursorDuringExecution } from "../ui/terminal.js";
 import { runUpdateEngine } from "../update/engine.js";
 export async function runUpdateCommand(options) {
     const renderScreen = createScreenRenderer();
     const restoreCursor = hideCursorDuringExecution({ screenBuffer: "alternate" });
     let finalScreen = "";
+    let latestState = undefined;
+    let animationFrameIndex = 0;
+    const animationTimer = setInterval(() => {
+        if (!latestState) {
+            return;
+        }
+        if (latestState.runCompletion === "finished") {
+            return;
+        }
+        if (latestState.currentPhase !== "running" && latestState.currentPhase !== "installing") {
+            return;
+        }
+        animationFrameIndex += 1;
+        renderScreen(buildScreenWithAnimationFrame(latestState, animationFrameIndex));
+    }, 100);
     try {
         const finalState = await runUpdateEngine({
             steps: options.steps,
@@ -16,12 +31,14 @@ export async function runUpdateCommand(options) {
             askForConfirmation: captureYesNo,
             collectVersions,
             onStateChanged: (state) => {
-                renderScreen(buildScreen(state));
+                latestState = state;
+                renderScreen(buildScreenWithAnimationFrame(state, animationFrameIndex));
             },
         });
         finalScreen = buildScreen(finalState);
     }
     finally {
+        clearInterval(animationTimer);
         restoreCursor();
     }
     if (finalScreen) {

package/dist/runner.js

@@ -1,4 +1,45 @@
 import { execa } from "execa";
+const FAILURE_OUTPUT_TAIL_LINE_LIMIT = 20;
+function splitNonEmptyLines(text) {
+    if (!text) {
+        return [];
+    }
+    return text.split(/\r?\n|\r/).filter(Boolean);
+}
+function buildFailureSummaryLines(shellCommand, error) {
+    const defaultMessage = error instanceof Error ? error.message : String(error);
+    if (typeof error !== "object" || error === null) {
+        return [
+            `[braeburn] Command failed: ${shellCommand}`,
+            `[braeburn] Error: ${defaultMessage}`,
+        ];
+    }
+    const errorDetails = error;
+    const summaryLines = [`[braeburn] Command failed: ${shellCommand}`];
+    if (typeof errorDetails.exitCode === "number") {
+        summaryLines.push(`[braeburn] Exit code: ${errorDetails.exitCode}`);
+    }
+    if (typeof errorDetails.signal === "string") {
+        summaryLines.push(`[braeburn] Signal: ${errorDetails.signal}`);
+    }
+    if (typeof errorDetails.shortMessage === "string" && errorDetails.shortMessage.length > 0) {
+        summaryLines.push(`[braeburn] ${errorDetails.shortMessage}`);
+    }
+    else {
+        summaryLines.push(`[braeburn] Error: ${defaultMessage}`);
+    }
+    const stderrTailLines = splitNonEmptyLines(errorDetails.stderr).slice(-FAILURE_OUTPUT_TAIL_LINE_LIMIT);
+    if (stderrTailLines.length > 0) {
+        summaryLines.push(`[braeburn] stderr tail (${stderrTailLines.length}):`);
+        summaryLines.push(...stderrTailLines.map((line) => `  ${line}`));
+    }
+    const stdoutTailLines = splitNonEmptyLines(errorDetails.stdout).slice(-FAILURE_OUTPUT_TAIL_LINE_LIMIT);
+    if (stdoutTailLines.length > 0) {
+        summaryLines.push(`[braeburn] stdout tail (${stdoutTailLines.length}):`);
+        summaryLines.push(...stdoutTailLines.map((line) => `  ${line}`));
+    }
+    return summaryLines;
+}
 export async function runShellCommand(options) {
     const subprocess = execa("bash", ["-c", options.shellCommand], {
         all: true,
@@ -18,7 +59,16 @@ export async function runShellCommand(options) {
             options.logWriter(line);
         }
     });
-    await subprocess;
+    try {
+        await subprocess;
+    }
+    catch (error) {
+        const failureSummaryLines = buildFailureSummaryLines(options.shellCommand, error);
+        for (const line of failureSummaryLines) {
+            await options.logWriter(line);
+        }
+        throw error;
+    }
 }
 export async function doesShellCommandSucceed(options) {
     const result = await execa("bash", ["-c", options.shellCommand], {

package/dist/steps/nvm.js

@@ -2,19 +2,27 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { checkPathExists } from "./runtime.js";
 const NVM_DIRECTORY = join(homedir(), ".nvm");
+const NVM_SCRIPT_PATH = join(NVM_DIRECTORY, "nvm.sh");
 // nvm is a shell function sourced from nvm.sh — it cannot be invoked as a
 // standalone binary, so we source it explicitly inside each bash invocation.
-const NVM_SOURCE_PREFIX = `export NVM_DIR="${NVM_DIRECTORY}" && source "$NVM_DIR/nvm.sh"`;
+const NVM_SOURCE_PREFIX = `export NVM_DIR="${NVM_DIRECTORY}" && source "$NVM_DIR/nvm.sh" --no-use`;
+const NVM_INSTALL_COMMAND = `${NVM_SOURCE_PREFIX} && ` +
+    `CURRENT_NODE_VERSION="$(nvm current)" && ` +
+    `if [ "$CURRENT_NODE_VERSION" = "none" ] || [ "$CURRENT_NODE_VERSION" = "system" ]; then ` +
+    `nvm install node; ` +
+    `else ` +
+    `nvm install node --reinstall-packages-from="$CURRENT_NODE_VERSION"; ` +
+    `fi`;
 const nvmStep = {
     id: "nvm",
     name: "Node.js (nvm)",
     stage: "runtime",
     description: "Install the latest Node.js via nvm, migrating packages from the current version",
     async checkIsAvailable() {
-        return checkPathExists(NVM_DIRECTORY);
+        return checkPathExists(NVM_SCRIPT_PATH);
     },
     async run(context) {
-        await context.runStep(`${NVM_SOURCE_PREFIX} && nvm install node --reinstall-packages-from=node`);
+        await context.runStep(NVM_INSTALL_COMMAND);
     },
 };
 export default nvmStep;

package/dist/ui/activityIndicator.d.ts

@@ -0,0 +1 @@
+export declare function getActivityIndicatorFrame(frameIndex: number): string;

package/dist/ui/activityIndicator.js

@@ -0,0 +1,5 @@
+const ACTIVITY_FRAMES = ["◐", "◓", "◑", "◒"];
+export function getActivityIndicatorFrame(frameIndex) {
+    const normalizedFrameIndex = Math.abs(Math.trunc(frameIndex));
+    return ACTIVITY_FRAMES[normalizedFrameIndex % ACTIVITY_FRAMES.length];
+}

package/dist/ui/currentStep.d.ts

@@ -4,6 +4,7 @@ type ActiveStepOptions = {
     stepNumber: number;
     totalSteps: number;
     phase: StepPhase;
+    activityFrameIndex?: number;
 };
 export declare function buildActiveStepLines(options: ActiveStepOptions): string[];
 export {};

package/dist/ui/currentStep.js

@@ -1,6 +1,8 @@
 import chalk from "chalk";
+import { getActivityIndicatorFrame } from "./activityIndicator.js";
 export function buildActiveStepLines(options) {
     const { step, stepNumber, totalSteps, phase } = options;
+    const activityFrameIndex = options.activityFrameIndex ?? 0;
     const isRunning = phase === "running" || phase === "installing";
     const lines = [
         chalk.dim(`  ${"─".repeat(3)} Step ${stepNumber}/${totalSteps}  `) +
@@ -10,7 +12,7 @@ export function buildActiveStepLines(options) {
     ];
     if (isRunning) {
         const label = phase === "installing" ? "Installing..." : "Running...";
-        lines.push(`  ${chalk.blue("▶")} ${label}`);
+        lines.push(`  ${chalk.blue(getActivityIndicatorFrame(activityFrameIndex))} ${label}`);
     }
     return lines;
 }

package/dist/ui/header.d.ts

@@ -2,7 +2,7 @@ import type { DisplayStep, StepPhase, CompletedStepRecord, LogoVisibility } from
 import type { TerminalDimensions } from "./outputBox.js";
 type LogoLayout = "side-by-side" | "stacked" | "none";
 export declare function determineLogoLayout(logoLines: string[], dimensions?: TerminalDimensions): LogoLayout;
-export declare function stepTrackerIcon(phase: StepPhase): string;
+export declare function stepTrackerIcon(phase: StepPhase, activityFrameIndex?: number): string;
 export declare function isActivePhase(phase: StepPhase): boolean;
 export declare function deriveAllStepPhases(steps: DisplayStep[], currentStepIndex: number, currentPhase: StepPhase, completedStepRecords: CompletedStepRecord[]): StepPhase[];
 type BuildHeaderOptions = {
@@ -12,6 +12,7 @@ type BuildHeaderOptions = {
     currentStepIndex: number;
     currentPhase: StepPhase;
     completedStepRecords: CompletedStepRecord[];
+    activityFrameIndex?: number;
     terminalDimensions?: TerminalDimensions;
 };
 export declare function buildHeaderLines(options: BuildHeaderOptions): string[];

package/dist/ui/header.js

@@ -1,5 +1,6 @@
 import chalk from "chalk";
 import { LOGO_ART } from "../logo.js";
+import { getActivityIndicatorFrame } from "./activityIndicator.js";
 const LOGO_COLUMN_WIDTH = 32;
 const LOGO_SEPARATOR = "    ";
 const MIN_SIDE_BY_SIDE_COLS = LOGO_COLUMN_WIDTH + LOGO_SEPARATOR.length + 20; // 56
@@ -14,16 +15,16 @@ export function determineLogoLayout(logoLines, dimensions) {
     }
     return "none";
 }
-export function stepTrackerIcon(phase) {
+export function stepTrackerIcon(phase, activityFrameIndex = 0) {
     if (phase === "complete")
         return chalk.green("✓ ");
     if (phase === "failed")
         return chalk.red("✗ ");
     if (phase === "skipped" || phase === "not-available")
         return chalk.dim("– ");
-    if (phase === "running" ||
-        phase === "installing" ||
-        phase === "prompting-to-run" ||
+    if (phase === "running" || phase === "installing")
+        return chalk.cyan(`${getActivityIndicatorFrame(activityFrameIndex)} `);
+    if (phase === "prompting-to-run" ||
         phase === "prompting-to-install" ||
         phase === "checking-availability")
         return chalk.cyan("→ ");
@@ -47,6 +48,7 @@ export function deriveAllStepPhases(steps, currentStepIndex, currentPhase, compl
 }
 export function buildHeaderLines(options) {
     const { steps, version, logoVisibility, currentStepIndex, currentPhase, completedStepRecords } = options;
+    const activityFrameIndex = options.activityFrameIndex ?? 0;
     const phases = deriveAllStepPhases(steps, currentStepIndex, currentPhase, completedStepRecords);
     const hasRuntimeSteps = steps.some((step) => step.stage === "runtime");
     const hasToolsSteps = steps.some((step) => step.stage === "tools");
@@ -64,7 +66,7 @@ export function buildHeaderLines(options) {
                 stepLines.push(chalk.dim("Tools"));
             }
         }
-        const icon = stepTrackerIcon(phases[stepIndex]);
+        const icon = stepTrackerIcon(phases[stepIndex], activityFrameIndex);
         const name = isActivePhase(phases[stepIndex]) ? chalk.white(step.name) : chalk.dim(step.name);
         stepLines.push(`${icon}${name}`);
     }

package/dist/ui/screen.d.ts

@@ -3,3 +3,4 @@ import type { AppState } from "./state.js";
 export type ScreenRenderer = (content: string) => void;
 export declare function createScreenRenderer(output?: NodeJS.WritableStream): ScreenRenderer;
 export declare function buildScreen(state: AppState, terminalDimensions?: TerminalDimensions): string;
+export declare function buildScreenWithAnimationFrame(state: AppState, activityFrameIndex: number, terminalDimensions?: TerminalDimensions): string;

package/dist/ui/screen.js

@@ -2,7 +2,7 @@ import { buildHeaderLines } from "./header.js";
 import { buildActiveStepLines } from "./currentStep.js";
 import { buildOutputBoxLines } from "./outputBox.js";
 import { buildPromptLines } from "./prompt.js";
-import { buildVersionReportLines } from "./versionReport.js";
+import { buildFailedStepLogHintLines, buildVersionReportLines } from "./versionReport.js";
 export function createScreenRenderer(output = process.stdout) {
     return (content) => {
         output.write("\x1b[H\x1b[2J");
@@ -10,7 +10,20 @@ export function createScreenRenderer(output = process.stdout) {
     };
 }
 export function buildScreen(state, terminalDimensions) {
+    return buildScreenWithAnimationFrame(state, 0, terminalDimensions);
+}
+export function buildScreenWithAnimationFrame(state, activityFrameIndex, terminalDimensions) {
     const lines = [];
+    const failedStepIds = state.completedStepRecords.flatMap((record, stepIndex) => {
+        if (record.phase !== "failed") {
+            return [];
+        }
+        const failedStep = state.steps[stepIndex];
+        if (!failedStep) {
+            return [];
+        }
+        return [failedStep.id];
+    });
     lines.push(...buildHeaderLines({
         steps: state.steps,
         version: state.version,
@@ -18,6 +31,7 @@ export function buildScreen(state, terminalDimensions) {
         currentStepIndex: state.currentStepIndex,
         currentPhase: state.currentPhase,
         completedStepRecords: state.completedStepRecords,
+        activityFrameIndex,
         terminalDimensions,
     }));
     lines.push("");
@@ -26,6 +40,10 @@ export function buildScreen(state, terminalDimensions) {
             lines.push("");
             lines.push(...buildVersionReportLines(state.versionReport));
         }
+        if (failedStepIds.length > 0) {
+            lines.push("");
+            lines.push(...buildFailedStepLogHintLines(failedStepIds));
+        }
     }
     else {
         const currentStep = state.steps[state.currentStepIndex];
@@ -36,6 +54,7 @@ export function buildScreen(state, terminalDimensions) {
                 stepNumber: state.currentStepIndex + 1,
                 totalSteps: state.steps.length,
                 phase: state.currentPhase,
+                activityFrameIndex,
             }));
             const isShowingOutput = (state.currentPhase === "running" || state.currentPhase === "installing") &&
                 state.currentOutputLines.length > 0;

package/dist/ui/versionReport.d.ts

@@ -1,2 +1,3 @@
 import type { ResolvedVersion } from "./state.js";
 export declare function buildVersionReportLines(versions: ResolvedVersion[]): string[];
+export declare function buildFailedStepLogHintLines(failedStepIds: string[]): string[];

package/dist/ui/versionReport.js

@@ -7,3 +7,6 @@ export function buildVersionReportLines(versions) {
         `  ${chalk.green.bold("✓")} ${chalk.bold("All done!")}`,
     ];
 }
+export function buildFailedStepLogHintLines(failedStepIds) {
+    return failedStepIds.map((stepId) => `  ${chalk.red.bold("✗")} ${chalk.bold(`Step ${stepId} failed.`)} ${chalk.dim(`Please run braeburn log --${stepId} to see what happened.`)}`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braeburn",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "description": "macOS system updater CLI",
   "type": "module",
   "bin": {