braeburn 1.5.1 → 1.6.0

package/dist/commands/update.js

@@ -1,14 +1,54 @@
+import readline from "node:readline";
 import { collectVersions } from "../update/versionCollector.js";
 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 { cancelActiveShellCommand } from "../runner.js";
+function shouldCaptureRuntimeAbortKey(state) {
+    return state?.currentPhase === "running" || state?.currentPhase === "installing";
+}
 export async function runUpdateCommand(options) {
     const renderScreen = createScreenRenderer();
     const restoreCursor = hideCursorDuringExecution({ screenBuffer: "alternate" });
     let finalScreen = "";
     let latestState = undefined;
+    let runtimeAbortKeyCaptureEnabled = false;
     let animationFrameIndex = 0;
+    const handleRuntimeKeypress = (typedCharacter, key) => {
+        if (key?.ctrl && key?.name === "c") {
+            process.stdout.write("\x1b[?25h\n");
+            process.exit(130);
+        }
+        const isQuitRequest = typedCharacter === "q" || typedCharacter === "Q";
+        if (!isQuitRequest) {
+            return;
+        }
+        cancelActiveShellCommand();
+    };
+    const enableRuntimeAbortKeyCapture = () => {
+        if (runtimeAbortKeyCaptureEnabled) {
+            return;
+        }
+        readline.emitKeypressEvents(process.stdin);
+        process.stdin.on("keypress", handleRuntimeKeypress);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        runtimeAbortKeyCaptureEnabled = true;
+    };
+    const disableRuntimeAbortKeyCapture = () => {
+        if (!runtimeAbortKeyCaptureEnabled) {
+            return;
+        }
+        process.stdin.removeListener("keypress", handleRuntimeKeypress);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+        runtimeAbortKeyCaptureEnabled = false;
+    };
     const animationTimer = setInterval(() => {
         if (!latestState) {
             return;
@@ -32,12 +72,19 @@ export async function runUpdateCommand(options) {
             collectVersions,
             onStateChanged: (state) => {
                 latestState = state;
+                if (shouldCaptureRuntimeAbortKey(state)) {
+                    enableRuntimeAbortKeyCapture();
+                }
+                else {
+                    disableRuntimeAbortKeyCapture();
+                }
                 renderScreen(buildScreenWithAnimationFrame(state, animationFrameIndex));
             },
         });
         finalScreen = buildScreen(finalState);
     }
     finally {
+        disableRuntimeAbortKeyCapture();
         clearInterval(animationTimer);
         restoreCursor();
     }

package/dist/runner.d.ts

@@ -10,7 +10,14 @@ type RunCommandOptions = {
     onOutputLine: OutputLineCallback;
     logWriter: StepLogWriter;
 };
+export declare class ShellCommandCanceledError extends Error {
+    readonly shellCommand: string;
+    readonly originalError: unknown;
+    constructor(shellCommand: string, originalError: unknown);
+}
+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

@@ -1,5 +1,25 @@
 import { execa } from "execa";
 const FAILURE_OUTPUT_TAIL_LINE_LIMIT = 20;
+let activeShellCommandSubprocess;
+const userCanceledSubprocesses = new WeakSet();
+export class ShellCommandCanceledError extends Error {
+    shellCommand;
+    originalError;
+    constructor(shellCommand, originalError) {
+        super(`Command canceled by user: ${shellCommand}`);
+        this.name = "ShellCommandCanceledError";
+        this.shellCommand = shellCommand;
+        this.originalError = originalError;
+    }
+}
+export function cancelActiveShellCommand() {
+    if (!activeShellCommandSubprocess) {
+        return false;
+    }
+    userCanceledSubprocesses.add(activeShellCommandSubprocess);
+    activeShellCommandSubprocess.kill("SIGTERM");
+    return true;
+}
 function splitNonEmptyLines(text) {
     if (!text) {
         return [];
@@ -40,35 +60,87 @@ 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) {
+            failureSummaryLines.push("[braeburn] Command canceled by user input (q).");
+        }
         for (const line of failureSummaryLines) {
             await options.logWriter(line);
         }
+        if (commandWasCanceledByUser) {
+            throw new ShellCommandCanceledError(options.shellCommand, error);
+        }
         throw error;
     }
+    finally {
+        if (activeShellCommandSubprocess === subprocess) {
+            activeShellCommandSubprocess = undefined;
+        }
+    }
+}
+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], {

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/currentStep.js

@@ -11,7 +11,9 @@ export function buildActiveStepLines(options) {
         `  ${chalk.dim("·")} ${chalk.dim.italic(step.description)}`,
     ];
     if (isRunning) {
-        const label = phase === "installing" ? "Installing..." : "Running...";
+        const label = phase === "installing"
+            ? "Installing... press q to end this step"
+            : "Running... press q to end this step";
         lines.push(`  ${chalk.blue(getActivityIndicatorFrame(activityFrameIndex))} ${label}`);
     }
     return lines;

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/dist/update/engine.js

@@ -1,5 +1,5 @@
 import { createLogWriterForStep } from "../logger.js";
-import { runShellCommand } 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";
@@ -26,6 +26,9 @@ async function resolvePrompt(promptMode, askForConfirmation) {
 function reportState(state, onStateChanged) {
     onStateChanged(state);
 }
+function wasStepCanceledByUser(error) {
+    return error instanceof ShellCommandCanceledError;
+}
 export async function runUpdateEngine(options) {
     const dependencies = resolveDependencies(options.dependencies);
     const state = createInitialUpdateState(toDisplaySteps(options.steps), options.version, options.logoVisibility);
@@ -75,10 +78,16 @@ export async function runUpdateEngine(options) {
                     logWriter: installLogWriter,
                 });
             }
-            catch {
+            catch (error) {
+                if (wasStepCanceledByUser(error)) {
+                    promptMode = "interactive";
+                }
                 state.currentPhase = "failed";
                 reportState(state, options.onStateChanged);
-                state.completedStepRecords.push({ phase: "failed", summaryNote: "install failed" });
+                state.completedStepRecords.push({
+                    phase: "failed",
+                    summaryNote: wasStepCanceledByUser(error) ? "canceled by user" : "install failed",
+                });
                 continue;
             }
         }
@@ -109,11 +118,17 @@ export async function runUpdateEngine(options) {
             state.completedStepRecords.push({ phase: "complete", summaryNote: "updated" });
         }
         catch (error) {
+            if (wasStepCanceledByUser(error)) {
+                promptMode = "interactive";
+            }
             const errorMessage = error instanceof Error ? error.message : String(error);
             state.currentPhase = "failed";
             state.currentOutputLines = [];
             reportState(state, options.onStateChanged);
-            state.completedStepRecords.push({ phase: "failed", summaryNote: errorMessage });
+            state.completedStepRecords.push({
+                phase: "failed",
+                summaryNote: wasStepCanceledByUser(error) ? "canceled by user" : errorMessage,
+            });
         }
     }
     state.runCompletion = "finished";

package/package.json

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