braeburn 1.3.1 → 1.4.1

package/README.md

@@ -24,7 +24,9 @@ braeburn homebrew npm # run specific steps only
 |---|---|
 | `braeburn [steps...] [-y]` | Run update steps (default) |
 | `braeburn log [step]` | View the latest output log for a step |
-| `braeburn config` | View current configuration |
+| `braeburn config` | Show config subcommand help |
+| `braeburn config list` | Print current configuration |
+| `braeburn config update` | Open interactive configuration editor |
 | `braeburn config update --no-<step>` | Disable a step |
 | `braeburn config update --<step>` | Re-enable a step |
 

package/dist/commands/config.d.ts

@@ -2,6 +2,7 @@ import { type BraeburnConfig } from "../config.js";
 import type { Step } from "../steps/index.js";
 type RunConfigCommandOptions = {
     allSteps: Step[];
+    outputMode: "interactive" | "non-interactive";
 };
 type DesiredState = "enable" | "disable";
 type RunConfigUpdateCommandOptions = {
@@ -20,4 +21,10 @@ type ConfigUpdateResult = {
 };
 export declare function applyConfigUpdates(config: BraeburnConfig, settingUpdates: Record<string, DesiredState>): ConfigUpdateResult;
 export declare function runConfigUpdateCommand(options: RunConfigUpdateCommandOptions): Promise<void>;
+type BuildConfigTableOutputOptions = {
+    config: BraeburnConfig;
+    configPath: string;
+    allSteps: Step[];
+};
+export declare function buildConfigTableOutput(options: BuildConfigTableOutputOptions): string;
 export {};

package/dist/commands/config.js

@@ -1,33 +1,22 @@
+import readline from "node:readline";
 import chalk from "chalk";
 import { readConfig, writeConfig, resolveConfigPath, isSettingEnabled, isStepEnabled, isLogoEnabled, applySettingToConfig, PROTECTED_STEP_IDS, DEFAULT_OFF_STEP_IDS, } from "../config.js";
+import { createScreenRenderer } from "../ui/screen.js";
+import { hideCursorDuringExecution } from "../ui/terminal.js";
 export async function runConfigCommand(options) {
-    const { allSteps } = options;
+    const { allSteps, outputMode } = options;
     const config = await readConfig();
     const configPath = await resolveConfigPath();
-    const STEP_COL = 12;
-    const DIVIDER = "─".repeat(STEP_COL + 16);
-    process.stdout.write(`Config: ${chalk.dim(configPath)}\n\n`);
-    process.stdout.write(`${"Step".padEnd(STEP_COL)}Status\n`);
-    process.stdout.write(`${DIVIDER}\n`);
-    const logoEnabled = isLogoEnabled(config);
-    process.stdout.write(`${"logo".padEnd(STEP_COL)}${logoEnabled ? chalk.green("enabled") : chalk.red("disabled")}\n`);
-    process.stdout.write(`${DIVIDER}\n`);
-    for (const step of allSteps) {
-        const isProtected = PROTECTED_STEP_IDS.has(step.id);
-        const enabled = isStepEnabled(config, step.id);
-        let statusText;
-        if (isProtected) {
-            statusText = chalk.dim("always enabled");
-        }
-        else if (enabled) {
-            statusText = chalk.green("enabled");
-        }
-        else {
-            statusText = chalk.red("disabled");
-        }
-        process.stdout.write(`${step.id.padEnd(STEP_COL)}${statusText}\n`);
+    if (outputMode === "non-interactive") {
+        process.stdout.write(buildConfigTableOutput({ config, configPath, allSteps }));
+        return;
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        process.stderr.write("Interactive mode requires a TTY. Showing non-interactive output.\n\n");
+        process.stdout.write(buildConfigTableOutput({ config, configPath, allSteps }));
+        return;
     }
-    process.stdout.write(`\n`);
+    await runInteractiveConfigView({ config, configPath, allSteps });
 }
 export function applyConfigUpdates(config, settingUpdates) {
     let updatedConfig = config;
@@ -74,6 +63,180 @@ export async function runConfigUpdateCommand(options) {
     const configPath = await resolveConfigPath();
     process.stdout.write(`\nConfig saved to ${chalk.dim(configPath)}\n`);
 }
+export function buildConfigTableOutput(options) {
+    const { config, configPath, allSteps } = options;
+    const lines = [];
+    const stepColumnWidth = 12;
+    const divider = "─".repeat(stepColumnWidth + 16);
+    lines.push(`Config: ${chalk.dim(configPath)}`);
+    lines.push("");
+    lines.push(`${"Step".padEnd(stepColumnWidth)}Status`);
+    lines.push(divider);
+    const logoEnabled = isLogoEnabled(config);
+    lines.push(`${"logo".padEnd(stepColumnWidth)}${logoEnabled ? chalk.green("enabled") : chalk.red("disabled")}`);
+    lines.push(divider);
+    for (const step of allSteps) {
+        const isProtected = PROTECTED_STEP_IDS.has(step.id);
+        const enabled = isStepEnabled(config, step.id);
+        let statusText;
+        if (isProtected) {
+            statusText = chalk.dim("always enabled");
+        }
+        else if (enabled) {
+            statusText = chalk.green("enabled");
+        }
+        else {
+            statusText = chalk.red("disabled");
+        }
+        lines.push(`${step.id.padEnd(stepColumnWidth)}${statusText}`);
+    }
+    lines.push("");
+    return lines.join("\n") + "\n";
+}
+function buildConfigViewItems(config, allSteps) {
+    const viewItems = [
+        {
+            id: "logo",
+            label: "logo",
+            description: "Show the braeburn logo in command output",
+            protection: "configurable",
+            selection: isLogoEnabled(config) ? "enabled" : "disabled",
+        },
+    ];
+    for (const step of allSteps) {
+        viewItems.push({
+            id: step.id,
+            label: step.id,
+            description: step.description,
+            protection: PROTECTED_STEP_IDS.has(step.id) ? "protected" : "configurable",
+            selection: isStepEnabled(config, step.id) ? "enabled" : "disabled",
+        });
+    }
+    return viewItems;
+}
+function buildInteractiveConfigScreen(options) {
+    const { configPath, items, cursorIndex } = options;
+    const lines = [];
+    lines.push(`Config: ${chalk.dim(configPath)}`);
+    lines.push("");
+    lines.push(`  ${chalk.dim("↑↓ navigate    Space toggle    Return save    q quit")}`);
+    lines.push("");
+    for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+        const item = items[itemIndex];
+        const isCursor = itemIndex === cursorIndex;
+        const cursor = isCursor ? chalk.cyan("›") : " ";
+        const marker = item.selection === "enabled" ? chalk.green("●") : chalk.dim("○");
+        const label = isCursor ? chalk.bold.white(item.label.padEnd(12)) : chalk.white(item.label.padEnd(12));
+        let status;
+        if (item.protection === "protected") {
+            status = chalk.dim("always enabled");
+        }
+        else if (item.selection === "enabled") {
+            status = chalk.green("enabled");
+        }
+        else {
+            status = chalk.red("disabled");
+        }
+        lines.push(`  ${cursor} ${marker}  ${label} ${status}`);
+        if (isCursor) {
+            lines.push(`        ${chalk.dim(item.description)}`);
+        }
+    }
+    const enabledCount = items.filter((item) => item.selection === "enabled").length;
+    lines.push("");
+    lines.push(`  ${chalk.dim(`${enabledCount} of ${items.length} settings enabled`)}`);
+    lines.push("");
+    return lines.join("\n") + "\n";
+}
+async function runInteractiveConfigView(options) {
+    const { config, configPath, allSteps } = options;
+    const render = createScreenRenderer();
+    const restoreCursor = hideCursorDuringExecution({ screenBuffer: "alternate" });
+    const items = buildConfigViewItems(config, allSteps);
+    let cursorIndex = 0;
+    let completionOutput = "";
+    try {
+        render(buildInteractiveConfigScreen({ configPath, items, cursorIndex }));
+        const interactionResult = await new Promise((resolve) => {
+            readline.emitKeypressEvents(process.stdin);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(true);
+            }
+            const completeInteraction = (result) => {
+                process.stdin.removeListener("keypress", onKeypress);
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode(false);
+                }
+                process.stdin.pause();
+                resolve(result);
+            };
+            const onKeypress = (_char, key) => {
+                if (key.ctrl && key.name === "c") {
+                    process.exit(130);
+                }
+                if (key.name === "up" || key.name === "k") {
+                    cursorIndex = Math.max(0, cursorIndex - 1);
+                    render(buildInteractiveConfigScreen({ configPath, items, cursorIndex }));
+                    return;
+                }
+                if (key.name === "down" || key.name === "j") {
+                    cursorIndex = Math.min(items.length - 1, cursorIndex + 1);
+                    render(buildInteractiveConfigScreen({ configPath, items, cursorIndex }));
+                    return;
+                }
+                if (key.name === "space") {
+                    const selectedItem = items[cursorIndex];
+                    if (selectedItem.protection === "configurable") {
+                        selectedItem.selection = selectedItem.selection === "enabled" ? "disabled" : "enabled";
+                        render(buildInteractiveConfigScreen({ configPath, items, cursorIndex }));
+                    }
+                    return;
+                }
+                if (key.name === "return") {
+                    completeInteraction("save");
+                    return;
+                }
+                if (key.name === "q" || key.name === "escape") {
+                    completeInteraction("cancel");
+                }
+            };
+            process.stdin.on("keypress", onKeypress);
+            process.stdin.resume();
+        });
+        if (interactionResult === "cancel") {
+            completionOutput = "No changes saved.\n";
+        }
+        else {
+            const settingUpdates = {};
+            for (const item of items) {
+                if (item.protection === "protected") {
+                    continue;
+                }
+                settingUpdates[item.id] = item.selection === "enabled" ? "enable" : "disable";
+            }
+            const { updatedConfig, changes } = applyConfigUpdates(config, settingUpdates);
+            if (changes.length === 0) {
+                completionOutput = "No changes — already set as requested.\n";
+            }
+            else {
+                await writeCleanConfig(updatedConfig);
+                const outputLines = [];
+                for (const { label, from, to } of changes) {
+                    const fromLabel = from === "enable" ? chalk.green("enabled") : chalk.red("disabled");
+                    const toLabel = to === "enable" ? chalk.green("enabled") : chalk.red("disabled");
+                    outputLines.push(`  ${label.padEnd(12)} ${fromLabel} → ${toLabel}`);
+                }
+                outputLines.push("");
+                outputLines.push(`Config saved to ${chalk.dim(configPath)}`);
+                completionOutput = `${outputLines.join("\n")}\n`;
+            }
+        }
+    }
+    finally {
+        restoreCursor();
+    }
+    process.stdout.write(completionOutput);
+}
 async function writeCleanConfig(config) {
     const cleaned = { steps: {} };
     for (const [stepId, value] of Object.entries(config.steps)) {

package/dist/commands/setup.d.ts

@@ -1,9 +1,17 @@
 import type { Step } from "../steps/index.js";
+import type { StepStage } from "../update/state.js";
 export type SelectionState = "selected" | "deselected";
 export type ProtectionStatus = "protected" | "configurable";
 export type AvailabilityStatus = "available" | "unavailable";
+export type SetupStepView = {
+    id: string;
+    name: string;
+    description: string;
+    stage: StepStage;
+    brewPackageToInstall?: string;
+};
 export type SelectableStep = {
-    step: Step;
+    step: SetupStepView;
     selection: SelectionState;
     protection: ProtectionStatus;
     availability: AvailabilityStatus;

package/dist/commands/setup.js

@@ -73,64 +73,75 @@ export function buildSetupScreen(items, cursorIndex) {
 }
 export async function runSetupCommand(allSteps) {
     const render = createScreenRenderer();
-    hideCursorDuringExecution();
-    render(buildLoadingScreen());
-    const availabilityResults = await Promise.all(allSteps.map((step) => step.checkIsAvailable()));
-    const items = allSteps.map((step, stepIndex) => ({
-        step,
-        selection: PROTECTED_STEP_IDS.has(step.id) || step.stage === "tools" ? "selected" : "deselected",
-        protection: PROTECTED_STEP_IDS.has(step.id) ? "protected" : "configurable",
-        availability: availabilityResults[stepIndex] ? "available" : "unavailable",
-    }));
-    let cursorIndex = 0;
-    render(buildSetupScreen(items, cursorIndex));
-    await new Promise((resolve) => {
-        readline.emitKeypressEvents(process.stdin);
-        if (process.stdin.isTTY)
-            process.stdin.setRawMode(true);
-        const handleKeypress = (_char, key) => {
-            if (key?.ctrl && key?.name === "c") {
-                process.exit(130);
-            }
-            if (key?.name === "up" || key?.name === "k") {
-                cursorIndex = Math.max(0, cursorIndex - 1);
-                render(buildSetupScreen(items, cursorIndex));
-            }
-            else if (key?.name === "down" || key?.name === "j") {
-                cursorIndex = Math.min(items.length - 1, cursorIndex + 1);
-                render(buildSetupScreen(items, cursorIndex));
-            }
-            else if (key?.name === "space") {
-                const item = items[cursorIndex];
-                if (item.protection === "configurable") {
-                    item.selection = item.selection === "selected" ? "deselected" : "selected";
+    const restoreCursor = hideCursorDuringExecution({ screenBuffer: "alternate" });
+    try {
+        render(buildLoadingScreen());
+        const availabilityResults = await Promise.all(allSteps.map((step) => step.checkIsAvailable()));
+        const items = allSteps.map((step, stepIndex) => ({
+            step: {
+                id: step.id,
+                name: step.name,
+                description: step.description,
+                stage: step.stage,
+                brewPackageToInstall: step.brewPackageToInstall,
+            },
+            selection: PROTECTED_STEP_IDS.has(step.id) || step.stage === "tools" ? "selected" : "deselected",
+            protection: PROTECTED_STEP_IDS.has(step.id) ? "protected" : "configurable",
+            availability: availabilityResults[stepIndex] ? "available" : "unavailable",
+        }));
+        let cursorIndex = 0;
+        render(buildSetupScreen(items, cursorIndex));
+        await new Promise((resolve) => {
+            readline.emitKeypressEvents(process.stdin);
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(true);
+            const handleKeypress = (_char, key) => {
+                if (key?.ctrl && key?.name === "c") {
+                    process.exit(130);
+                }
+                if (key?.name === "up" || key?.name === "k") {
+                    cursorIndex = Math.max(0, cursorIndex - 1);
                     render(buildSetupScreen(items, cursorIndex));
                 }
+                else if (key?.name === "down" || key?.name === "j") {
+                    cursorIndex = Math.min(items.length - 1, cursorIndex + 1);
+                    render(buildSetupScreen(items, cursorIndex));
+                }
+                else if (key?.name === "space") {
+                    const item = items[cursorIndex];
+                    if (item.protection === "configurable") {
+                        item.selection = item.selection === "selected" ? "deselected" : "selected";
+                        render(buildSetupScreen(items, cursorIndex));
+                    }
+                }
+                else if (key?.name === "return") {
+                    process.stdin.removeListener("keypress", handleKeypress);
+                    if (process.stdin.isTTY)
+                        process.stdin.setRawMode(false);
+                    process.stdin.pause();
+                    resolve();
+                }
+            };
+            process.stdin.on("keypress", handleKeypress);
+            process.stdin.resume();
+        });
+        const stepsConfig = {};
+        for (const item of items) {
+            if (item.protection === "configurable" && item.selection === "deselected") {
+                stepsConfig[item.step.id] = false;
             }
-            else if (key?.name === "return") {
-                process.stdin.removeListener("keypress", handleKeypress);
-                if (process.stdin.isTTY)
-                    process.stdin.setRawMode(false);
-                process.stdin.pause();
-                resolve();
-            }
-        };
-        process.stdin.on("keypress", handleKeypress);
-        process.stdin.resume();
-    });
-    const stepsConfig = {};
-    for (const item of items) {
-        if (item.protection === "configurable" && item.selection === "deselected") {
-            stepsConfig[item.step.id] = false;
         }
+        await writeConfig({ steps: stepsConfig });
+        const confirmationLines = [
+            chalk.yellow(LOGO_ART),
+            "",
+            `  ${chalk.green("\u2713")}  Setup complete! Starting your first update\u2026`,
+            "",
+        ];
+        render(confirmationLines.join("\n") + "\n");
+        await new Promise((resolve) => setTimeout(resolve, 800));
+    }
+    finally {
+        restoreCursor();
     }
-    await writeConfig({ steps: stepsConfig });
-    const confirmationLines = [
-        chalk.yellow(LOGO_ART),
-        "",
-        `  ${chalk.green("\u2713")}  Setup complete! Starting your first update\u2026`,
-        "",
-    ];
-    render(confirmationLines.join("\n") + "\n");
-    await new Promise((resolve) => setTimeout(resolve, 800));
 }

package/dist/commands/update.d.ts

@@ -1,6 +1,6 @@
+import { type PromptMode } from "../update/engine.js";
+import type { LogoVisibility } from "../update/state.js";
 import type { Step } from "../steps/index.js";
-type PromptMode = "interactive" | "auto-accept";
-type LogoVisibility = "visible" | "hidden";
 type RunUpdateCommandOptions = {
     steps: Step[];
     promptMode: PromptMode;

package/dist/commands/update.js

@@ -1,109 +1,30 @@
-import { runShellCommand } from "../runner.js";
-import { createLogWriterForStep } from "../logger.js";
-import { collectVersions } from "../ui/versionReport.js";
+import { collectVersions } from "../update/versionCollector.js";
 import { captureYesNo } from "../ui/prompt.js";
-import { createInitialAppState } from "../ui/state.js";
 import { buildScreen, createScreenRenderer } from "../ui/screen.js";
 import { hideCursorDuringExecution } from "../ui/terminal.js";
-import { createDefaultStepRunContext } from "../steps/index.js";
+import { runUpdateEngine } from "../update/engine.js";
 export async function runUpdateCommand(options) {
-    const { steps, version } = options;
-    let autoAccept = options.promptMode === "auto-accept";
-    const state = createInitialAppState(steps, version, options.logoVisibility);
     const renderScreen = createScreenRenderer();
-    hideCursorDuringExecution();
-    renderScreen(buildScreen(state));
-    for (let stepIndex = 0; stepIndex < steps.length; stepIndex++) {
-        const step = steps[stepIndex];
-        state.currentStepIndex = stepIndex;
-        state.currentPhase = "checking-availability";
-        state.currentOutputLines = [];
-        state.currentPrompt = undefined;
-        renderScreen(buildScreen(state));
-        const isAvailable = await step.checkIsAvailable();
-        if (!isAvailable && !step.brewPackageToInstall) {
-            state.currentPhase = "not-available";
-            renderScreen(buildScreen(state));
-            state.completedStepRecords.push({ phase: "not-available", summaryNote: "not installed" });
-            continue;
-        }
-        if (!isAvailable && step.brewPackageToInstall) {
-            state.currentPhase = "prompting-to-install";
-            state.currentPrompt = {
-                question: `Install ${step.name} via Homebrew? (brew install ${step.brewPackageToInstall})`,
-            };
-            renderScreen(buildScreen(state));
-            const installAnswer = autoAccept ? "yes" : await captureYesNo();
-            if (installAnswer === "force")
-                autoAccept = true;
-            const shouldInstall = installAnswer !== "no";
-            state.currentPrompt = undefined;
-            if (!shouldInstall) {
-                state.currentPhase = "skipped";
+    const restoreCursor = hideCursorDuringExecution({ screenBuffer: "alternate" });
+    let finalScreen = "";
+    try {
+        const finalState = await runUpdateEngine({
+            steps: options.steps,
+            promptMode: options.promptMode,
+            version: options.version,
+            logoVisibility: options.logoVisibility,
+            askForConfirmation: captureYesNo,
+            collectVersions,
+            onStateChanged: (state) => {
                 renderScreen(buildScreen(state));
-                state.completedStepRecords.push({ phase: "skipped" });
-                continue;
-            }
-            state.currentPhase = "installing";
-            renderScreen(buildScreen(state));
-            try {
-                const installLogWriter = await createLogWriterForStep(`${step.id}-install`);
-                await runShellCommand({
-                    shellCommand: `brew install ${step.brewPackageToInstall}`,
-                    onOutputLine: (line) => {
-                        state.currentOutputLines.push(line);
-                        renderScreen(buildScreen(state));
-                    },
-                    logWriter: installLogWriter,
-                });
-            }
-            catch {
-                state.currentPhase = "failed";
-                renderScreen(buildScreen(state));
-                state.completedStepRecords.push({ phase: "failed", summaryNote: "install failed" });
-                continue;
-            }
-        }
-        state.currentPhase = "prompting-to-run";
-        state.currentPrompt = { question: `Run ${step.name} update?`, warning: step.warning };
-        renderScreen(buildScreen(state));
-        const runAnswer = autoAccept ? "yes" : await captureYesNo();
-        if (runAnswer === "force")
-            autoAccept = true;
-        const shouldRun = runAnswer !== "no";
-        state.currentPrompt = undefined;
-        if (!shouldRun) {
-            state.currentPhase = "skipped";
-            renderScreen(buildScreen(state));
-            state.completedStepRecords.push({ phase: "skipped" });
-            continue;
-        }
-        state.currentPhase = "running";
-        state.currentOutputLines = [];
-        renderScreen(buildScreen(state));
-        const stepLogWriter = await createLogWriterForStep(step.id);
-        try {
-            await step.run(createDefaultStepRunContext((line) => {
-                state.currentOutputLines.push(line);
-                renderScreen(buildScreen(state));
-            }, stepLogWriter));
-            state.currentPhase = "complete";
-            state.currentOutputLines = [];
-            renderScreen(buildScreen(state));
-            state.completedStepRecords.push({ phase: "complete", summaryNote: "updated" });
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            state.currentPhase = "failed";
-            state.currentOutputLines = [];
-            renderScreen(buildScreen(state));
-            state.completedStepRecords.push({ phase: "failed", summaryNote: errorMessage });
-        }
+            },
+        });
+        finalScreen = buildScreen(finalState);
+    }
+    finally {
+        restoreCursor();
+    }
+    if (finalScreen) {
+        process.stdout.write(finalScreen);
     }
-    state.runCompletion = "finished";
-    state.currentOutputLines = [];
-    state.currentPrompt = undefined;
-    renderScreen(buildScreen(state));
-    state.versionReport = await collectVersions();
-    renderScreen(buildScreen(state));
 }

package/dist/index.js

@@ -3,24 +3,12 @@ import { Command } from "commander";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
-import { homebrewStep, masStep, ohmyzshStep, npmStep, pipStep, pyenvStep, nvmStep, dotnetStep, macosStep, cleanupStep, } from "./steps/index.js";
+import { ALL_STEPS } from "./steps/catalog.js";
 import { 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";
 import { readConfig, isStepEnabled, isLogoEnabled, PROTECTED_STEP_IDS, configFileExists } from "./config.js";
-const ALL_STEPS = [
-    pyenvStep,
-    nvmStep,
-    homebrewStep,
-    masStep,
-    ohmyzshStep,
-    npmStep,
-    pipStep,
-    dotnetStep,
-    macosStep,
-    cleanupStep,
-];
 const STEP_IDS_BY_NAME = new Map(ALL_STEPS.map((step) => [step.id, step]));
 const requireFromThis = createRequire(import.meta.url);
 const packageJson = requireFromThis(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"));
@@ -115,15 +103,25 @@ Examples:
 const configCommand = program
     .command("config")
     .description("View or edit braeburn configuration")
+    .action(() => {
+    configCommand.outputHelp();
+});
+configCommand
+    .command("list")
+    .description("Print current configuration")
     .action(async () => {
-    await runConfigCommand({ allSteps: ALL_STEPS });
+    await runConfigCommand({
+        allSteps: ALL_STEPS,
+        outputMode: "non-interactive",
+    });
 });
 const configurableSteps = ALL_STEPS.filter((step) => !PROTECTED_STEP_IDS.has(step.id));
 const configUpdateCommand = configCommand
     .command("update")
-    .description("Enable or disable individual update steps")
+    .description("Edit configuration (interactive by default, flags for direct updates)")
     .addHelpText("after", `
 Examples:
+  braeburn config update                     Open interactive config editor
   braeburn config update --no-logo           Hide the logo
   braeburn config update --no-ohmyzsh        Disable Oh My Zsh updates
   braeburn config update --no-pip --no-nvm   Disable pip and nvm updates
@@ -135,7 +133,7 @@ for (const step of configurableSteps) {
     configUpdateCommand.option(`--no-${step.id}`, `Disable ${step.name} updates`);
     configUpdateCommand.option(`--${step.id}`, `Enable ${step.name} updates`);
 }
-configUpdateCommand.action(function () {
+configUpdateCommand.action(async function () {
     // Commander defaults --no-* to true, so we use getOptionValueSource to detect explicit CLI flags.
     const settingUpdates = {};
     for (const step of configurableSteps) {
@@ -148,7 +146,14 @@ configUpdateCommand.action(function () {
     if (logoSource === "cli") {
         settingUpdates["logo"] = configUpdateCommand.opts().logo ? "enable" : "disable";
     }
-    runConfigUpdateCommand({ settingUpdates, allSteps: ALL_STEPS });
+    if (Object.keys(settingUpdates).length === 0) {
+        await runConfigCommand({
+            allSteps: ALL_STEPS,
+            outputMode: "interactive",
+        });
+        return;
+    }
+    await runConfigUpdateCommand({ settingUpdates, allSteps: ALL_STEPS });
 });
 function resolveStepsByIds(stepIds) {
     const resolvedSteps = [];

package/dist/runner.js

@@ -5,14 +5,14 @@ export async function runShellCommand(options) {
         reject: true,
     });
     subprocess.stdout?.on("data", (chunk) => {
-        const lines = String(chunk).split("\n").filter(Boolean);
+        const lines = String(chunk).split(/\r?\n|\r/).filter(Boolean);
         for (const line of lines) {
             options.onOutputLine({ text: line, source: "stdout" });
             options.logWriter(line);
         }
     });
     subprocess.stderr?.on("data", (chunk) => {
-        const lines = String(chunk).split("\n").filter(Boolean);
+        const lines = String(chunk).split(/\r?\n|\r/).filter(Boolean);
         for (const line of lines) {
             options.onOutputLine({ text: line, source: "stderr" });
             options.logWriter(line);

package/dist/steps/catalog.d.ts

@@ -0,0 +1,2 @@
+import { type Step } from "./index.js";
+export declare const ALL_STEPS: Step[];