braeburn 1.5.2 → 2.0.0

package/dist/commands/update.d.ts

@@ -1,5 +1,5 @@
 import { type PromptMode } from "../update/engine.js";
-import type { LogoVisibility } from "../update/state.js";
+import { type LogoVisibility } from "../update/state.js";
 import type { Step } from "../steps/index.js";
 type RunUpdateCommandOptions = {
     steps: Step[];
@@ -7,5 +7,12 @@ type RunUpdateCommandOptions = {
     logoVisibility: LogoVisibility;
     version: string;
 };
-export declare function runUpdateCommand(options: RunUpdateCommandOptions): Promise<void>;
+export type UpdateCommandResult = {
+    failedStepCount: number;
+};
+type ExitCodeWritable = {
+    exitCode: string | number | null | undefined;
+};
+export declare function applyUpdateCommandResult(updateCommandResult: UpdateCommandResult, processWithExitCode: ExitCodeWritable): void;
+export declare function runUpdateCommand(options: RunUpdateCommandOptions): Promise<UpdateCommandResult>;
 export {};

package/dist/commands/update.js

@@ -4,10 +4,16 @@ import { captureYesNo } from "../ui/prompt.js";
 import { buildScreen, buildScreenWithAnimationFrame, createScreenRenderer } from "../ui/screen.js";
 import { hideCursorDuringExecution } from "../ui/terminal.js";
 import { runUpdateEngine } from "../update/engine.js";
+import { countFailedSteps } from "../update/state.js";
 import { cancelActiveShellCommand } from "../runner.js";
 function shouldCaptureRuntimeAbortKey(state) {
     return state?.currentPhase === "running" || state?.currentPhase === "installing";
 }
+export function applyUpdateCommandResult(updateCommandResult, processWithExitCode) {
+    if (updateCommandResult.failedStepCount > 0) {
+        processWithExitCode.exitCode = 1;
+    }
+}
 export async function runUpdateCommand(options) {
     const renderScreen = createScreenRenderer();
     const restoreCursor = hideCursorDuringExecution({ screenBuffer: "alternate" });
@@ -15,6 +21,7 @@ export async function runUpdateCommand(options) {
     let latestState = undefined;
     let runtimeAbortKeyCaptureEnabled = false;
     let animationFrameIndex = 0;
+    let updateCommandResult = { failedStepCount: 0 };
     const handleRuntimeKeypress = (typedCharacter, key) => {
         if (key?.ctrl && key?.name === "c") {
             process.stdout.write("\x1b[?25h\n");
@@ -82,6 +89,9 @@ export async function runUpdateCommand(options) {
             },
         });
         finalScreen = buildScreen(finalState);
+        updateCommandResult = {
+            failedStepCount: countFailedSteps(finalState.completedStepRecords),
+        };
     }
     finally {
         disableRuntimeAbortKeyCapture();
@@ -91,4 +101,5 @@ export async function runUpdateCommand(options) {
     if (finalScreen) {
         process.stdout.write(finalScreen);
     }
+    return updateCommandResult;
 }

package/dist/index.js

@@ -4,7 +4,7 @@ import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import { ALL_STEPS } from "./steps/catalog.js";
-import { runUpdateCommand } from "./commands/update.js";
+import { applyUpdateCommandResult, runUpdateCommand } from "./commands/update.js";
 import { runLogCommand, runLogListCommand } from "./commands/log.js";
 import { runConfigCommand, runConfigUpdateCommand } from "./commands/config.js";
 import { runSetupCommand } from "./commands/setup.js";
@@ -70,12 +70,13 @@ Examples:
         stepsToRun = stepsToRun.filter((step) => isStepEnabled(config, step.id));
     }
     const logoIsEnabled = options.logo !== false && isLogoEnabled(config);
-    await runUpdateCommand({
+    const updateCommandResult = await runUpdateCommand({
         steps: stepsToRun,
         promptMode: autoYes ? "auto-accept" : "interactive",
         logoVisibility: logoIsEnabled ? "visible" : "hidden",
         version: BRAEBURN_VERSION,
     });
+    applyUpdateCommandResult(updateCommandResult, process);
 });
 program
     .command("log")

package/dist/runner.d.ts

@@ -17,6 +17,7 @@ export declare class ShellCommandCanceledError extends Error {
 }
 export declare function cancelActiveShellCommand(): boolean;
 export declare function runShellCommand(options: RunCommandOptions): Promise<void>;
+export declare function runShellCommandAndCaptureOutput(options: RunCommandOptions): Promise<string>;
 type CheckCommandOptions = {
     shellCommand: string;
 };

package/dist/runner.js

@@ -60,30 +60,62 @@ function buildFailureSummaryLines(shellCommand, error) {
     }
     return summaryLines;
 }
-export async function runShellCommand(options) {
+function createBufferedLineEmitter(emitLine) {
+    let pendingText = "";
+    return {
+        appendChunk(chunk) {
+            pendingText += String(chunk);
+            const lineParts = pendingText.split(/\r?\n|\r/);
+            pendingText = lineParts.pop() ?? "";
+            for (const linePart of lineParts) {
+                if (linePart.length === 0) {
+                    continue;
+                }
+                emitLine(linePart);
+            }
+        },
+        flushPendingLine() {
+            if (pendingText.length === 0) {
+                return;
+            }
+            emitLine(pendingText);
+            pendingText = "";
+        },
+    };
+}
+async function executeShellCommand(options) {
+    const capturedOutputLines = [];
     const subprocess = execa("bash", ["-c", options.shellCommand], {
         all: true,
         reject: true,
     });
     activeShellCommandSubprocess = subprocess;
+    const emitOutputLine = (line) => {
+        capturedOutputLines.push(line.text);
+        options.onOutputLine(line);
+        options.logWriter(line.text);
+    };
+    const stdoutEmitter = createBufferedLineEmitter((line) => {
+        emitOutputLine({ text: line, source: "stdout" });
+    });
+    const stderrEmitter = createBufferedLineEmitter((line) => {
+        emitOutputLine({ text: line, source: "stderr" });
+    });
     subprocess.stdout?.on("data", (chunk) => {
-        const lines = String(chunk).split(/\r?\n|\r/).filter(Boolean);
-        for (const line of lines) {
-            options.onOutputLine({ text: line, source: "stdout" });
-            options.logWriter(line);
-        }
+        stdoutEmitter.appendChunk(chunk);
     });
     subprocess.stderr?.on("data", (chunk) => {
-        const lines = String(chunk).split(/\r?\n|\r/).filter(Boolean);
-        for (const line of lines) {
-            options.onOutputLine({ text: line, source: "stderr" });
-            options.logWriter(line);
-        }
+        stderrEmitter.appendChunk(chunk);
     });
     try {
         await subprocess;
+        stdoutEmitter.flushPendingLine();
+        stderrEmitter.flushPendingLine();
+        return { capturedOutput: capturedOutputLines.join("\n") };
     }
     catch (error) {
+        stdoutEmitter.flushPendingLine();
+        stderrEmitter.flushPendingLine();
         const commandWasCanceledByUser = userCanceledSubprocesses.has(subprocess);
         const failureSummaryLines = buildFailureSummaryLines(options.shellCommand, error);
         if (commandWasCanceledByUser) {
@@ -103,6 +135,13 @@ export async function runShellCommand(options) {
         }
     }
 }
+export async function runShellCommand(options) {
+    await executeShellCommand(options);
+}
+export async function runShellCommandAndCaptureOutput(options) {
+    const result = await executeShellCommand(options);
+    return result.capturedOutput;
+}
 export async function doesShellCommandSucceed(options) {
     const result = await execa("bash", ["-c", options.shellCommand], {
         reject: false,

package/dist/steps/index.d.ts

@@ -3,7 +3,7 @@ export type { StepCategoryId, StepCategoryDefinition, } from "./categories.js";
 export { listStepCategoryDefinitions, getStepCategoryLabel, } from "./categories.js";
 export type { CategorySection, } from "./grouping.js";
 export { buildCategorySectionsInOrder, } from "./grouping.js";
-export { checkCommandExists, checkPathExists, runStep, createDefaultStepRunContext, } from "./runtime.js";
+export { checkCommandExists, checkPathExists, runStep, runStepAndCaptureOutput, createDefaultStepRunContext, } from "./runtime.js";
 export { default as homebrewStep } from "./homebrew.js";
 export { default as masStep } from "./mas.js";
 export { default as ohmyzshStep } from "./ohmyzsh.js";

package/dist/steps/index.js

@@ -1,6 +1,6 @@
 export { listStepCategoryDefinitions, getStepCategoryLabel, } from "./categories.js";
 export { buildCategorySectionsInOrder, } from "./grouping.js";
-export { checkCommandExists, checkPathExists, runStep, createDefaultStepRunContext, } from "./runtime.js";
+export { checkCommandExists, checkPathExists, runStep, runStepAndCaptureOutput, createDefaultStepRunContext, } from "./runtime.js";
 export { default as homebrewStep } from "./homebrew.js";
 export { default as masStep } from "./mas.js";
 export { default as ohmyzshStep } from "./ohmyzsh.js";

package/dist/steps/macos.js

@@ -7,10 +7,11 @@ const macosStep = {
         return true;
     },
     async run(context) {
-        const updateListOutput = await context.captureOutput({
-            shellCommand: "softwareupdate -l 2>&1",
+        context.onOutputLine({
+            text: "Checking for macOS updates...",
+            source: "stdout",
         });
-        context.logWriter(updateListOutput);
+        const updateListOutput = await context.runStepAndCaptureOutput("softwareupdate -l 2>&1");
         const noUpdatesAvailable = updateListOutput.includes("No new software available");
         if (noUpdatesAvailable) {
             context.onOutputLine({
@@ -19,7 +20,6 @@ const macosStep = {
             });
             return;
         }
-        context.onOutputLine({ text: updateListOutput, source: "stdout" });
         context.onOutputLine({
             text: "Updates found — installing now...",
             source: "stdout",

package/dist/steps/runtime.d.ts

@@ -4,4 +4,5 @@ import type { StepRunContext } from "./types.js";
 export declare function checkCommandExists(command: string): Promise<boolean>;
 export declare function checkPathExists(filePath: string): Promise<boolean>;
 export declare function runStep(shellCommand: string, context: StepRunContext): Promise<void>;
+export declare function runStepAndCaptureOutput(shellCommand: string, context: StepRunContext): Promise<string>;
 export declare function createDefaultStepRunContext(onOutputLine: OutputLineCallback, logWriter: StepLogWriter): StepRunContext;

package/dist/steps/runtime.js

@@ -1,4 +1,4 @@
-import { doesShellCommandSucceed, runShellCommand, captureShellCommandOutput, } from "../runner.js";
+import { doesShellCommandSucceed, runShellCommand, captureShellCommandOutput, runShellCommandAndCaptureOutput, } from "../runner.js";
 export async function checkCommandExists(command) {
     return doesShellCommandSucceed({ shellCommand: `command -v ${command}` });
 }
@@ -12,11 +12,19 @@ export async function runStep(shellCommand, context) {
         logWriter: context.logWriter,
     });
 }
+export async function runStepAndCaptureOutput(shellCommand, context) {
+    return runShellCommandAndCaptureOutput({
+        shellCommand,
+        onOutputLine: context.onOutputLine,
+        logWriter: context.logWriter,
+    });
+}
 export function createDefaultStepRunContext(onOutputLine, logWriter) {
     const context = {
         onOutputLine,
         logWriter,
         runStep: (shellCommand) => runStep(shellCommand, context),
+        runStepAndCaptureOutput: (shellCommand) => runStepAndCaptureOutput(shellCommand, context),
         captureOutput: captureShellCommandOutput,
     };
     return context;

package/dist/steps/types.d.ts

@@ -5,6 +5,7 @@ export type StepRunContext = {
     onOutputLine: OutputLineCallback;
     logWriter: StepLogWriter;
     runStep: (shellCommand: string) => Promise<void>;
+    runStepAndCaptureOutput: (shellCommand: string) => Promise<string>;
     captureOutput: (options: {
         shellCommand: string;
     }) => Promise<string>;

package/dist/ui/header.d.ts

@@ -1,5 +1,5 @@
 import type { DisplayStep, StepPhase, CompletedStepRecord, LogoVisibility } from "./state.js";
-import type { TerminalDimensions } from "./outputBox.js";
+import type { TerminalDimensions } from "./outputLines.js";
 type LogoLayout = "side-by-side" | "stacked" | "none";
 export declare function determineLogoLayout(logoLines: string[], dimensions?: TerminalDimensions): LogoLayout;
 export declare function stepTrackerIcon(phase: StepPhase, activityFrameIndex?: number): string;

package/dist/ui/outputLines.d.ts

@@ -0,0 +1,6 @@
+import type { CommandOutputLine } from "../runner.js";
+export type TerminalDimensions = {
+    columns: number;
+    rows: number;
+};
+export declare function buildStepOutputLines(lines: CommandOutputLine[], dimensions?: TerminalDimensions): string[];

package/dist/ui/outputLines.js

@@ -0,0 +1,33 @@
+import chalk from "chalk";
+const INDENT = "  ";
+const HEADER_LINES_APPROXIMATE = 18;
+const MINIMUM_VISIBLE_LINES = 5;
+function maxVisibleLines(rows) {
+    const available = rows - HEADER_LINES_APPROXIMATE;
+    return Math.max(MINIMUM_VISIBLE_LINES, available);
+}
+function maxLineWidth(columns) {
+    return Math.max(0, Math.min(columns, 120) - INDENT.length);
+}
+function resolveTerminalDimensions(dimensions) {
+    return dimensions ?? {
+        columns: process.stdout.columns ?? 80,
+        rows: process.stdout.rows ?? 40,
+    };
+}
+function expandRenderedLines(lines) {
+    return lines.flatMap((line) => line.text.split(/\r?\n|\r/).map((text) => ({
+        text,
+        source: line.source,
+    })));
+}
+export function buildStepOutputLines(lines, dimensions) {
+    const resolved = resolveTerminalDimensions(dimensions);
+    const visibleLines = expandRenderedLines(lines).slice(-maxVisibleLines(resolved.rows));
+    const width = maxLineWidth(resolved.columns);
+    return visibleLines.map((line) => {
+        const truncated = line.text.slice(0, width);
+        const colored = line.source === "stderr" ? chalk.yellow(truncated) : chalk.dim(truncated);
+        return `${INDENT}${colored}`;
+    });
+}

package/dist/ui/screen.d.ts

@@ -1,5 +1,5 @@
-import { type TerminalDimensions } from "./outputBox.js";
-import type { AppState } from "./state.js";
+import { type TerminalDimensions } from "./outputLines.js";
+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;

package/dist/ui/screen.js

@@ -1,8 +1,9 @@
 import { buildHeaderLines } from "./header.js";
 import { buildActiveStepLines } from "./currentStep.js";
-import { buildOutputBoxLines } from "./outputBox.js";
+import { buildStepOutputLines } from "./outputLines.js";
 import { buildPromptLines } from "./prompt.js";
 import { buildFailedStepLogHintLines, buildVersionReportLines } from "./versionReport.js";
+import { countFailedSteps } from "./state.js";
 export function createScreenRenderer(output = process.stdout) {
     return (content) => {
         output.write("\x1b[H\x1b[2J");
@@ -12,18 +13,48 @@ 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") {
+function buildFailedStepLogHints(state) {
+    return state.completedStepRecords.flatMap((completedStepRecord, stepIndex) => {
+        if (completedStepRecord.phase !== "failed") {
             return [];
         }
         const failedStep = state.steps[stepIndex];
         if (!failedStep) {
             return [];
         }
-        return [failedStep.id];
+        return [{
+                stepId: failedStep.id,
+                logStepId: completedStepRecord.logStepId ?? failedStep.id,
+            }];
     });
+}
+function findLatestFailedStepDisplay(state) {
+    for (let stepIndex = state.completedStepRecords.length - 1; stepIndex >= 0; stepIndex -= 1) {
+        const completedStepRecord = state.completedStepRecords[stepIndex];
+        if (completedStepRecord?.phase !== "failed") {
+            continue;
+        }
+        const failedStep = state.steps[stepIndex];
+        if (!failedStep) {
+            continue;
+        }
+        const failureOutputLines = completedStepRecord.failureOutputLines;
+        if (!failureOutputLines || failureOutputLines.length === 0) {
+            continue;
+        }
+        return {
+            step: failedStep,
+            stepNumber: stepIndex + 1,
+            failureOutputLines,
+        };
+    }
+    return undefined;
+}
+export function buildScreenWithAnimationFrame(state, activityFrameIndex, terminalDimensions) {
+    const lines = [];
+    const failedStepCount = countFailedSteps(state.completedStepRecords);
+    const failedStepLogHints = buildFailedStepLogHints(state);
+    const latestFailedStepDisplay = findLatestFailedStepDisplay(state);
     lines.push(...buildHeaderLines({
         steps: state.steps,
         version: state.version,
@@ -38,11 +69,26 @@ export function buildScreenWithAnimationFrame(state, activityFrameIndex, termina
     if (state.runCompletion === "finished") {
         if (state.versionReport) {
             lines.push("");
-            lines.push(...buildVersionReportLines(state.versionReport));
+            lines.push(...buildVersionReportLines({
+                versions: state.versionReport,
+                failedStepCount,
+            }));
+        }
+        if (failedStepLogHints.length > 0) {
+            lines.push("");
+            lines.push(...buildFailedStepLogHintLines(failedStepLogHints));
         }
-        if (failedStepIds.length > 0) {
+        if (latestFailedStepDisplay) {
+            lines.push("");
+            lines.push(...buildActiveStepLines({
+                step: latestFailedStepDisplay.step,
+                stepNumber: latestFailedStepDisplay.stepNumber,
+                totalSteps: state.steps.length,
+                phase: "failed",
+                activityFrameIndex,
+            }));
             lines.push("");
-            lines.push(...buildFailedStepLogHintLines(failedStepIds));
+            lines.push(...buildStepOutputLines(latestFailedStepDisplay.failureOutputLines, terminalDimensions));
         }
     }
     else {
@@ -56,11 +102,13 @@ export function buildScreenWithAnimationFrame(state, activityFrameIndex, termina
                 phase: state.currentPhase,
                 activityFrameIndex,
             }));
-            const isShowingOutput = (state.currentPhase === "running" || state.currentPhase === "installing") &&
+            const isShowingOutput = (state.currentPhase === "running" ||
+                state.currentPhase === "installing" ||
+                state.currentPhase === "failed") &&
                 state.currentOutputLines.length > 0;
             if (isShowingOutput) {
                 lines.push("");
-                lines.push(...buildOutputBoxLines(state.currentOutputLines, currentStep.name, terminalDimensions));
+                lines.push(...buildStepOutputLines(state.currentOutputLines, terminalDimensions));
             }
             if (state.currentPrompt) {
                 lines.push("");

package/dist/ui/state.d.ts

@@ -1 +1 @@
-export { type DisplayStep, type StepPhase, type CompletedStepRecord, type CurrentPrompt, type ResolvedVersion, type LogoVisibility, type RunCompletion, type UpdateState, type AppState, createInitialUpdateState, createInitialAppState, } from "../update/state.js";
+export { type DisplayStep, type StepPhase, type CompletedStepRecord, type CurrentPrompt, type ResolvedVersion, type LogoVisibility, type RunCompletion, type UpdateState, type AppState, createInitialUpdateState, createInitialAppState, countFailedSteps, } from "../update/state.js";

package/dist/ui/state.js

@@ -1 +1 @@
-export { createInitialUpdateState, createInitialAppState, } from "../update/state.js";
+export { createInitialUpdateState, createInitialAppState, countFailedSteps, } from "../update/state.js";

package/dist/ui/versionReport.d.ts

@@ -1,3 +1,11 @@
 import type { ResolvedVersion } from "./state.js";
-export declare function buildVersionReportLines(versions: ResolvedVersion[]): string[];
-export declare function buildFailedStepLogHintLines(failedStepIds: string[]): string[];
+export type VersionReportOptions = {
+    versions: ResolvedVersion[];
+    failedStepCount: number;
+};
+export type FailedStepLogHint = {
+    stepId: string;
+    logStepId: string;
+};
+export declare function buildVersionReportLines(options: VersionReportOptions): string[];
+export declare function buildFailedStepLogHintLines(failedStepLogHints: FailedStepLogHint[]): string[];

package/dist/ui/versionReport.js

@@ -1,12 +1,19 @@
 import chalk from "chalk";
-export function buildVersionReportLines(versions) {
+function buildCompletionSummaryLine(failedStepCount) {
+    if (failedStepCount === 0) {
+        return `  ${chalk.green.bold("✓")} ${chalk.bold("All done!")}`;
+    }
+    const failureLabel = failedStepCount === 1 ? "1 step failed" : `${failedStepCount} steps failed`;
+    return `  ${chalk.red.bold("✗")} ${chalk.bold(`Done (${failureLabel})`)}`;
+}
+export function buildVersionReportLines(options) {
     return [
         chalk.dim("  ─── Versions ─────────────────────────"),
-        ...versions.map(({ label, value }) => `  ${chalk.dim("·")} ${chalk.bold(label + ":")} ${chalk.dim(value)}`),
+        ...options.versions.map(({ label, value }) => `  ${chalk.dim("·")} ${chalk.bold(label + ":")} ${chalk.dim(value)}`),
         "",
-        `  ${chalk.green.bold("✓")} ${chalk.bold("All done!")}`,
+        buildCompletionSummaryLine(options.failedStepCount),
     ];
 }
-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.`)}`);
+export function buildFailedStepLogHintLines(failedStepLogHints) {
+    return failedStepLogHints.map(({ stepId, logStepId }) => `  ${chalk.red.bold("✗")} ${chalk.bold(`Step ${stepId} failed.`)} ${chalk.dim(`Please run braeburn log ${logStepId} to see what happened.`)}`);
 }

package/dist/update/engine.js

@@ -1,5 +1,5 @@
 import { createLogWriterForStep } from "../logger.js";
-import { runShellCommand, ShellCommandCanceledError } from "../runner.js";
+import { runShellCommand, ShellCommandCanceledError, } from "../runner.js";
 import { createDefaultStepRunContext } from "../steps/index.js";
 import { toDisplaySteps } from "./displayStep.js";
 import { createInitialUpdateState, } from "./state.js";
@@ -29,6 +29,24 @@ function reportState(state, onStateChanged) {
 function wasStepCanceledByUser(error) {
     return error instanceof ShellCommandCanceledError;
 }
+function createFailureOutputLines(currentOutputLines, error) {
+    if (currentOutputLines.length > 0) {
+        return [...currentOutputLines];
+    }
+    const errorMessage = error instanceof Error && error.message.length > 0
+        ? error.message
+        : "Command failed.";
+    return [{ text: errorMessage, source: "stderr" }];
+}
+function createFailedStepRecord(options) {
+    const errorMessage = options.error instanceof Error ? options.error.message : String(options.error);
+    return {
+        phase: "failed",
+        summaryNote: wasStepCanceledByUser(options.error) ? "canceled by user" : errorMessage,
+        logStepId: options.logStepId,
+        failureOutputLines: [...options.failureOutputLines],
+    };
+}
 export async function runUpdateEngine(options) {
     const dependencies = resolveDependencies(options.dependencies);
     const state = createInitialUpdateState(toDisplaySteps(options.steps), options.version, options.logoVisibility);
@@ -82,12 +100,15 @@ export async function runUpdateEngine(options) {
                 if (wasStepCanceledByUser(error)) {
                     promptMode = "interactive";
                 }
+                const failureOutputLines = createFailureOutputLines(state.currentOutputLines, error);
                 state.currentPhase = "failed";
+                state.currentOutputLines = failureOutputLines;
                 reportState(state, options.onStateChanged);
-                state.completedStepRecords.push({
-                    phase: "failed",
-                    summaryNote: wasStepCanceledByUser(error) ? "canceled by user" : "install failed",
-                });
+                state.completedStepRecords.push(createFailedStepRecord({
+                    error,
+                    failureOutputLines,
+                    logStepId: `${step.id}-install`,
+                }));
                 continue;
             }
         }
@@ -121,14 +142,15 @@ export async function runUpdateEngine(options) {
             if (wasStepCanceledByUser(error)) {
                 promptMode = "interactive";
             }
-            const errorMessage = error instanceof Error ? error.message : String(error);
+            const failureOutputLines = createFailureOutputLines(state.currentOutputLines, error);
             state.currentPhase = "failed";
-            state.currentOutputLines = [];
+            state.currentOutputLines = failureOutputLines;
             reportState(state, options.onStateChanged);
-            state.completedStepRecords.push({
-                phase: "failed",
-                summaryNote: wasStepCanceledByUser(error) ? "canceled by user" : errorMessage,
-            });
+            state.completedStepRecords.push(createFailedStepRecord({
+                error,
+                failureOutputLines,
+                logStepId: step.id,
+            }));
         }
     }
     state.runCompletion = "finished";

package/dist/update/state.d.ts

@@ -10,6 +10,8 @@ export type StepPhase = "pending" | "checking-availability" | "prompting-to-inst
 export type CompletedStepRecord = {
     phase: StepPhase;
     summaryNote?: string;
+    logStepId?: string;
+    failureOutputLines?: CommandOutputLine[];
 };
 export type CurrentPrompt = {
     question: string;
@@ -36,3 +38,4 @@ export type UpdateState = {
 export type AppState = UpdateState;
 export declare function createInitialUpdateState(steps: DisplayStep[], version: string, logoVisibility: LogoVisibility): UpdateState;
 export declare const createInitialAppState: typeof createInitialUpdateState;
+export declare function countFailedSteps(completedStepRecords: CompletedStepRecord[]): number;

package/dist/update/state.js

@@ -13,3 +13,6 @@ export function createInitialUpdateState(steps, version, logoVisibility) {
     };
 }
 export const createInitialAppState = createInitialUpdateState;
+export function countFailedSteps(completedStepRecords) {
+    return completedStepRecords.filter((completedStepRecord) => completedStepRecord.phase === "failed").length;
+}

package/package.json

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

package/dist/ui/outputBox.d.ts

@@ -1,6 +0,0 @@
-import type { CommandOutputLine } from "../runner.js";
-export type TerminalDimensions = {
-    columns: number;
-    rows: number;
-};
-export declare function buildOutputBoxLines(lines: CommandOutputLine[], stepName: string, dimensions?: TerminalDimensions): string[];

package/dist/ui/outputBox.js

@@ -1,35 +0,0 @@
-import chalk from "chalk";
-const INDENT = "  ";
-const HEADER_LINES_APPROXIMATE = 18;
-const OUTPUT_BOX_CHROME_LINES = 3;
-const MINIMUM_VISIBLE_LINES = 5;
-function maxVisibleLines(rows) {
-    const available = rows - HEADER_LINES_APPROXIMATE - OUTPUT_BOX_CHROME_LINES;
-    return Math.max(MINIMUM_VISIBLE_LINES, available);
-}
-function boxWidth(columns) {
-    return Math.min(columns, 120) - INDENT.length * 2;
-}
-function resolveTerminalDimensions(dimensions) {
-    return dimensions ?? {
-        columns: process.stdout.columns ?? 80,
-        rows: process.stdout.rows ?? 40,
-    };
-}
-export function buildOutputBoxLines(lines, stepName, dimensions) {
-    const resolved = resolveTerminalDimensions(dimensions);
-    const visibleLines = lines.slice(-maxVisibleLines(resolved.rows));
-    const width = boxWidth(resolved.columns);
-    const headerLabel = `─ ${stepName} output `;
-    const topDashes = "─".repeat(Math.max(0, width - headerLabel.length - 2));
-    const topBorder = chalk.dim(`${INDENT}┌${headerLabel}${topDashes}┐`);
-    const bottomBorder = chalk.dim(`${INDENT}└${"─".repeat(width - 2)}┘`);
-    const result = [topBorder];
-    for (const line of visibleLines) {
-        const truncated = line.text.slice(0, width - 4);
-        const colored = line.source === "stderr" ? chalk.yellow(truncated) : chalk.dim(truncated);
-        result.push(`${INDENT}${chalk.dim("│")} ${colored}`);
-    }
-    result.push(bottomBorder);
-    return result;
-}