braeburn 1.5.2 → 1.6.0

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,4 +1,4 @@
-import { type TerminalDimensions } from "./outputBox.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;

package/dist/ui/screen.js

@@ -1,6 +1,6 @@
 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";
 export function createScreenRenderer(output = process.stdout) {
@@ -60,7 +60,7 @@ export function buildScreenWithAnimationFrame(state, activityFrameIndex, termina
                 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braeburn",
-  "version": "1.5.2",
+  "version": "1.6.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;
-}