braeburn 1.5.1 → 1.5.2

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,6 +10,12 @@ 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>;
 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 [];
@@ -45,6 +65,7 @@ export async function runShellCommand(options) {
         all: true,
         reject: true,
     });
+    activeShellCommandSubprocess = subprocess;
     subprocess.stdout?.on("data", (chunk) => {
         const lines = String(chunk).split(/\r?\n|\r/).filter(Boolean);
         for (const line of lines) {
@@ -63,12 +84,24 @@ export async function runShellCommand(options) {
         await subprocess;
     }
     catch (error) {
+        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 doesShellCommandSucceed(options) {
     const result = await execa("bash", ["-c", options.shellCommand], {

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/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.5.2",
   "description": "macOS system updater CLI",
   "type": "module",
   "bin": {