braeburn 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sam Wagner [SSW]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/commands/config.d.ts

@@ -0,0 +1,11 @@
+import type { Step } from "../steps/index.js";
+type RunConfigCommandOptions = {
+    allSteps: Step[];
+};
+type RunConfigUpdateCommandOptions = {
+    stepUpdates: Record<string, boolean>;
+    allSteps: Step[];
+};
+export declare function runConfigCommand(options: RunConfigCommandOptions): Promise<void>;
+export declare function runConfigUpdateCommand(options: RunConfigUpdateCommandOptions): Promise<void>;
+export {};

package/dist/commands/config.js

@@ -0,0 +1,81 @@
+import chalk from "chalk";
+import { readConfig, writeConfig, resolveConfigPath, isStepEnabled, PROTECTED_STEP_IDS, } from "../config.js";
+export async function runConfigCommand(options) {
+    const { allSteps } = 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`);
+    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`);
+    }
+    process.stdout.write(`\n`);
+}
+export async function runConfigUpdateCommand(options) {
+    const { stepUpdates, allSteps } = options;
+    if (Object.keys(stepUpdates).length === 0) {
+        const configurableSteps = allSteps.filter((s) => !PROTECTED_STEP_IDS.has(s.id));
+        process.stdout.write("No changes — pass flags to enable or disable steps:\n\n");
+        for (const step of configurableSteps) {
+            process.stdout.write(`  ${`--no-${step.id}`.padEnd(18)} disable ${step.name}\n`);
+        }
+        process.stdout.write("\n");
+        for (const step of configurableSteps) {
+            process.stdout.write(`  ${`--${step.id}`.padEnd(18)} re-enable ${step.name}\n`);
+        }
+        process.stdout.write("\n");
+        return;
+    }
+    const config = await readConfig();
+    const changes = [];
+    for (const [stepId, newEnabled] of Object.entries(stepUpdates)) {
+        const currentlyEnabled = isStepEnabled(config, stepId);
+        if (currentlyEnabled !== newEnabled) {
+            changes.push({ stepId, from: currentlyEnabled, to: newEnabled });
+        }
+        if (newEnabled) {
+            // Re-enabling: remove from config so absent = enabled (keeps file minimal)
+            delete config.steps[stepId];
+        }
+        else {
+            config.steps[stepId] = false;
+        }
+    }
+    // Write even if no visible changes, in case the user is re-confirming state
+    await writeCleanConfig(config);
+    if (changes.length === 0) {
+        process.stdout.write("No changes — already set as requested.\n");
+        return;
+    }
+    for (const { stepId, from, to } of changes) {
+        const fromLabel = from ? chalk.green("enabled") : chalk.red("disabled");
+        const toLabel = to ? chalk.green("enabled") : chalk.red("disabled");
+        process.stdout.write(`  ${stepId.padEnd(12)} ${fromLabel} → ${toLabel}\n`);
+    }
+    const configPath = await resolveConfigPath();
+    process.stdout.write(`\nConfig saved to ${chalk.dim(configPath)}\n`);
+}
+async function writeCleanConfig(config) {
+    const cleaned = { steps: {} };
+    for (const [stepId, enabled] of Object.entries(config.steps)) {
+        if (enabled === false) {
+            cleaned.steps[stepId] = false;
+        }
+    }
+    await writeConfig(cleaned);
+}

package/dist/commands/log.d.ts

@@ -0,0 +1,6 @@
+type ShowLogOptions = {
+    stepId: string;
+};
+export declare function runLogCommand(options: ShowLogOptions): Promise<void>;
+export declare function runLogListCommand(): void;
+export {};

package/dist/commands/log.js

@@ -0,0 +1,35 @@
+import { createReadStream } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { findLatestLogFileForStep, listAllStepIdsWithLogs, } from "../logger.js";
+const BRAEBURN_LOG_DIRECTORY = join(homedir(), ".braeburn", "logs");
+function streamFileToStdout(filePath) {
+    return new Promise((resolve, reject) => {
+        const stream = createReadStream(filePath, { encoding: "utf-8" });
+        stream.on("data", (chunk) => process.stdout.write(String(chunk)));
+        stream.on("end", resolve);
+        stream.on("error", reject);
+    });
+}
+export async function runLogCommand(options) {
+    const logFilePath = findLatestLogFileForStep(options.stepId);
+    if (!logFilePath) {
+        process.stderr.write(`No logs found for step "${options.stepId}".\n` +
+            `Log files are stored in: ${BRAEBURN_LOG_DIRECTORY}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    await streamFileToStdout(logFilePath);
+}
+export function runLogListCommand() {
+    const stepIdsWithLogs = listAllStepIdsWithLogs();
+    if (stepIdsWithLogs.length === 0) {
+        process.stdout.write(`No logs found yet. Run braeburn to generate logs.\n`);
+        return;
+    }
+    process.stdout.write("Available step logs:\n\n");
+    for (const stepId of stepIdsWithLogs) {
+        process.stdout.write(`  ${stepId}\n`);
+    }
+    process.stdout.write(`\nUsage: braeburn log <step>  (e.g. braeburn log homebrew)\n`);
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,8 @@
+import type { Step } from "../steps/index.js";
+type RunUpdateCommandOptions = {
+    steps: Step[];
+    autoYes: boolean;
+    version: string;
+};
+export declare function runUpdateCommand(options: RunUpdateCommandOptions): Promise<void>;
+export {};

package/dist/commands/update.js

@@ -0,0 +1,110 @@
+import { runShellCommand } from "../runner.js";
+import { createLogWriterForStep } from "../logger.js";
+import { collectVersions } from "../ui/versionReport.js";
+import { captureYesNo } from "../ui/prompt.js";
+import { createInitialAppState } from "../ui/state.js";
+import { buildScreen, renderScreen } from "../ui/screen.js";
+export async function runUpdateCommand(options) {
+    const { steps, autoYes, version } = options;
+    const state = createInitialAppState(steps, version);
+    process.stdout.write("\x1b[?25l");
+    process.on("exit", () => process.stdout.write("\x1b[?25h"));
+    process.on("SIGINT", () => {
+        process.stdout.write("\x1b[?25h\n");
+        process.exit(130);
+    });
+    renderScreen(buildScreen(state));
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        state.currentStepIndex = i;
+        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 shouldInstall = autoYes || (await captureYesNo());
+            state.currentPrompt = undefined;
+            if (!shouldInstall) {
+                state.currentPhase = "skipped";
+                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;
+            }
+        }
+        const pipWarning = step.id === "pip"
+            ? "This updates all global pip3 packages, which can occasionally break tools."
+            : undefined;
+        state.currentPhase = "prompting-to-run";
+        state.currentPrompt = { question: `Run ${step.name} update?`, warning: pipWarning };
+        renderScreen(buildScreen(state));
+        const shouldRun = autoYes || (await captureYesNo());
+        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({
+                onOutputLine: (line) => {
+                    state.currentOutputLines.push(line);
+                    renderScreen(buildScreen(state));
+                },
+                logWriter: 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 });
+        }
+    }
+    state.isFinished = true;
+    state.currentOutputLines = [];
+    state.currentPrompt = undefined;
+    renderScreen(buildScreen(state));
+    state.versionReport = await collectVersions();
+    renderScreen(buildScreen(state));
+}

package/dist/config.d.ts

@@ -0,0 +1,9 @@
+/** Steps that cannot be disabled — brew is a hard runtime dependency. */
+export declare const PROTECTED_STEP_IDS: Set<string>;
+export type BraeburnConfig = {
+    steps: Record<string, boolean>;
+};
+export declare function resolveConfigPath(): Promise<string>;
+export declare function readConfig(): Promise<BraeburnConfig>;
+export declare function writeConfig(config: BraeburnConfig): Promise<void>;
+export declare function isStepEnabled(config: BraeburnConfig, stepId: string): boolean;

package/dist/config.js

@@ -0,0 +1,45 @@
+import { readFile, writeFile, mkdir, access } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { parse, stringify } from "smol-toml";
+/** Steps that cannot be disabled — brew is a hard runtime dependency. */
+export const PROTECTED_STEP_IDS = new Set(["homebrew"]);
+const EMPTY_CONFIG = { steps: {} };
+async function pathExists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveConfigPath() {
+    const xdgConfig = join(homedir(), ".config");
+    if (await pathExists(xdgConfig)) {
+        return join(xdgConfig, "braeburn", "config");
+    }
+    return join(homedir(), ".braeburn", "config");
+}
+export async function readConfig() {
+    const configPath = await resolveConfigPath();
+    try {
+        const raw = await readFile(configPath, "utf-8");
+        const parsed = parse(raw);
+        return { steps: parsed.steps ?? {} };
+    }
+    catch {
+        return structuredClone(EMPTY_CONFIG);
+    }
+}
+export async function writeConfig(config) {
+    const configPath = await resolveConfigPath();
+    await mkdir(join(configPath, ".."), { recursive: true });
+    await writeFile(configPath, stringify(config), "utf-8");
+}
+export function isStepEnabled(config, stepId) {
+    if (PROTECTED_STEP_IDS.has(stepId))
+        return true;
+    // Absent from config means enabled (opt-out model)
+    return config.steps[stepId] !== false;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+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 { runUpdateCommand } from "./commands/update.js";
+import { runLogCommand, runLogListCommand } from "./commands/log.js";
+import { runConfigCommand, runConfigUpdateCommand } from "./commands/config.js";
+import { readConfig, isStepEnabled, PROTECTED_STEP_IDS } from "./config.js";
+const ALL_STEPS = [
+    homebrewStep,
+    masStep,
+    ohmyzshStep,
+    npmStep,
+    pipStep,
+    pyenvStep,
+    nvmStep,
+    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"));
+const BRAEBURN_VERSION = packageJson.version;
+const program = new Command();
+program
+    .name("braeburn")
+    .description("macOS system updater")
+    .version(BRAEBURN_VERSION)
+    .helpCommand(false);
+program
+    .command("update", { isDefault: true })
+    .description("Run system update steps (default command)")
+    .argument("[steps...]", `Steps to run — omit to run all.\nAvailable: ${ALL_STEPS.map((s) => s.id).join(", ")}`)
+    .option("-y, --yes", "Auto-accept all prompts (default yes to everything)")
+    .option("-f, --force", "Alias for --yes")
+    .addHelpText("after", `
+Step descriptions:
+  homebrew   Update Homebrew itself and all installed formulae
+  mas        Upgrade Mac App Store apps  (requires: mas)
+  ohmyzsh    Update Oh My Zsh            (requires: ~/.oh-my-zsh)
+  npm        Update global npm packages  (requires: npm)
+  pip        Update global pip3 packages (requires: pip3) ⚠ may be fragile
+  pyenv      Upgrade pyenv, install latest Python 3.x (requires: pyenv or brew)
+  nvm        Update Node.js via nvm      (requires: ~/.nvm)
+  dotnet     Update .NET global tools    (requires: dotnet)
+  macos      Check for macOS updates, prompt to install
+  cleanup    Clean up Homebrew cache and old downloads
+
+Examples:
+  braeburn                  Run all steps interactively
+  braeburn -y               Run all steps, auto-accept everything
+  braeburn -fy              Same as above
+  braeburn homebrew npm     Run only the homebrew and npm steps
+  braeburn homebrew -y      Run only homebrew, auto-accept
+  `)
+    .action(async (stepArguments, options) => {
+    const autoYes = options.yes === true || options.force === true;
+    let stepsToRun = stepArguments.length === 0
+        ? ALL_STEPS
+        : resolveStepsByIds(stepArguments);
+    // When no explicit steps are requested, filter out steps disabled in config.
+    // Explicit step arguments always bypass config (user knows what they want).
+    if (stepArguments.length === 0) {
+        const config = await readConfig();
+        stepsToRun = stepsToRun.filter((step) => isStepEnabled(config, step.id));
+    }
+    await runUpdateCommand({
+        steps: stepsToRun,
+        autoYes,
+        version: BRAEBURN_VERSION,
+    });
+});
+program
+    .command("log")
+    .description("View the most recent output log for a given step")
+    .argument("[step]", "Step ID to view logs for (e.g. homebrew, npm, pip)")
+    .option("--homebrew", "Show latest Homebrew log")
+    .option("--mas", "Show latest Mac App Store log")
+    .option("--ohmyzsh", "Show latest Oh My Zsh log")
+    .option("--npm", "Show latest npm log")
+    .option("--pip", "Show latest pip3 log")
+    .option("--pyenv", "Show latest pyenv log")
+    .option("--nvm", "Show latest nvm log")
+    .option("--dotnet", "Show latest .NET log")
+    .option("--macos", "Show latest macOS update log")
+    .option("--cleanup", "Show latest cleanup log")
+    .addHelpText("after", `
+Examples:
+  braeburn log              List all available step logs
+  braeburn log homebrew     Show the latest Homebrew run log
+  braeburn log --brew       Same as above
+  braeburn log npm | less   Pipe log output through less
+  `)
+    .action((stepArgument, options) => {
+    const stepIdFromFlag = ALL_STEPS.map((step) => step.id).find((stepId) => options[stepId] === true);
+    const resolvedStepId = stepArgument ?? stepIdFromFlag;
+    if (!resolvedStepId) {
+        runLogListCommand();
+        return;
+    }
+    runLogCommand({ stepId: resolvedStepId });
+});
+const configCommand = program
+    .command("config")
+    .description("View or edit braeburn configuration")
+    .action(async () => {
+    await runConfigCommand({ allSteps: ALL_STEPS });
+});
+const configurableSteps = ALL_STEPS.filter((s) => !PROTECTED_STEP_IDS.has(s.id));
+const configUpdateCommand = configCommand
+    .command("update")
+    .description("Enable or disable individual update steps")
+    .addHelpText("after", `
+Examples:
+  braeburn config update --no-ohmyzsh        Disable Oh My Zsh updates
+  braeburn config update --no-pip --no-nvm   Disable pip and nvm updates
+  braeburn config update --ohmyzsh           Re-enable Oh My Zsh updates
+    `);
+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 () {
+    // Use getOptionValueSource to detect only flags explicitly passed on the CLI.
+    // Commander defaults --no-* to true, so we can't rely on option values alone.
+    const stepUpdates = {};
+    for (const step of configurableSteps) {
+        const source = configUpdateCommand.getOptionValueSource(step.id);
+        if (source === "cli") {
+            stepUpdates[step.id] = configUpdateCommand.opts()[step.id];
+        }
+    }
+    runConfigUpdateCommand({ stepUpdates, allSteps: ALL_STEPS });
+});
+function resolveStepsByIds(stepIds) {
+    const resolvedSteps = [];
+    for (const stepId of stepIds) {
+        const step = STEP_IDS_BY_NAME.get(stepId);
+        if (!step) {
+            process.stderr.write(`Unknown step: "${stepId}". Run braeburn --help to see available steps.\n`);
+            process.exit(1);
+        }
+        resolvedSteps.push(step);
+    }
+    return resolvedSteps;
+}
+program.parse();

package/dist/logger.d.ts

@@ -0,0 +1,4 @@
+export type StepLogWriter = (line: string) => Promise<void>;
+export declare function createLogWriterForStep(stepId: string): Promise<StepLogWriter>;
+export declare function findLatestLogFileForStep(stepId: string): string | null;
+export declare function listAllStepIdsWithLogs(): string[];

package/dist/logger.js

@@ -0,0 +1,44 @@
+import { mkdir, appendFile } from "node:fs/promises";
+import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const BRAEBURN_LOG_DIRECTORY = join(homedir(), ".braeburn", "logs");
+async function ensureLogDirectoryExists() {
+    if (existsSync(BRAEBURN_LOG_DIRECTORY)) {
+        return;
+    }
+    await mkdir(BRAEBURN_LOG_DIRECTORY, { recursive: true });
+}
+export async function createLogWriterForStep(stepId) {
+    await ensureLogDirectoryExists();
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const logFilePath = join(BRAEBURN_LOG_DIRECTORY, `${stepId}-${timestamp}.log`);
+    const writeLineToLog = async (line) => {
+        await appendFile(logFilePath, line + "\n", "utf-8");
+    };
+    return writeLineToLog;
+}
+export function findLatestLogFileForStep(stepId) {
+    if (!existsSync(BRAEBURN_LOG_DIRECTORY)) {
+        return null;
+    }
+    const allFiles = readdirSync(BRAEBURN_LOG_DIRECTORY);
+    const filesForThisStep = allFiles
+        .filter((fileName) => fileName.startsWith(`${stepId}-`))
+        .sort()
+        .reverse(); // most recent first
+    if (filesForThisStep.length === 0) {
+        return null;
+    }
+    return join(BRAEBURN_LOG_DIRECTORY, filesForThisStep[0]);
+}
+export function listAllStepIdsWithLogs() {
+    if (!existsSync(BRAEBURN_LOG_DIRECTORY)) {
+        return [];
+    }
+    const allFiles = readdirSync(BRAEBURN_LOG_DIRECTORY);
+    const stepIds = new Set(allFiles
+        .map((fileName) => fileName.split("-")[0])
+        .filter((maybeStepId) => Boolean(maybeStepId)));
+    return [...stepIds].sort();
+}

package/dist/logo.d.ts

@@ -0,0 +1 @@
+export declare const LOGO_ART = "  ;            \n               :x :           \n              .x$+x           \n    x+x;      XXX&            \n     :xx&&&   &&&             \n        +X +X x+  .:::        \n              ; X$$; :X$:     \n           $+ ;+              \n        .x:   : .             \n      ::      ;+X             \n               +$             \n                :";

package/dist/logo.js

@@ -0,0 +1,14 @@
+// The ASCII art is intentionally left-aligned with spaces as part of the design.
+// Keep the template literal formatting exactly as-is.
+export const LOGO_ART = `  ;            
+               :x :           
+              .x\$+x           
+    x+x;      XXX&            
+     :xx&&&   &&&             
+        +X +X x+  .:::        
+              ; X\$\$; :X\$:     
+           \$+ ;+              
+        .x:   : .             
+      ::      ;+X             
+               +\$             
+                :`;

package/dist/runner.d.ts

@@ -0,0 +1,21 @@
+import type { StepLogWriter } from "./logger.js";
+export type CommandOutputLine = {
+    text: string;
+    isError: boolean;
+};
+export type OutputLineCallback = (line: CommandOutputLine) => void;
+type RunCommandOptions = {
+    shellCommand: string;
+    onOutputLine: OutputLineCallback;
+    logWriter: StepLogWriter;
+};
+export declare function runShellCommand(options: RunCommandOptions): Promise<void>;
+type CheckCommandOptions = {
+    shellCommand: string;
+};
+export declare function doesShellCommandSucceed(options: CheckCommandOptions): Promise<boolean>;
+type CaptureCommandOptions = {
+    shellCommand: string;
+};
+export declare function captureShellCommandOutput(options: CaptureCommandOptions): Promise<string>;
+export {};

package/dist/runner.js

@@ -0,0 +1,34 @@
+import { execa } from "execa";
+export async function runShellCommand(options) {
+    const subprocess = execa("bash", ["-c", options.shellCommand], {
+        all: true,
+        reject: true,
+    });
+    subprocess.stdout?.on("data", (chunk) => {
+        const lines = String(chunk).split("\n").filter(Boolean);
+        for (const line of lines) {
+            options.onOutputLine({ text: line, isError: false });
+            options.logWriter(line);
+        }
+    });
+    subprocess.stderr?.on("data", (chunk) => {
+        const lines = String(chunk).split("\n").filter(Boolean);
+        for (const line of lines) {
+            options.onOutputLine({ text: line, isError: true });
+            options.logWriter(line);
+        }
+    });
+    await subprocess;
+}
+export async function doesShellCommandSucceed(options) {
+    const result = await execa("bash", ["-c", options.shellCommand], {
+        reject: false,
+    });
+    return result.exitCode === 0;
+}
+export async function captureShellCommandOutput(options) {
+    const result = await execa("bash", ["-c", options.shellCommand], {
+        reject: false,
+    });
+    return result.stdout.trim();
+}

package/dist/steps/cleanup.d.ts

@@ -0,0 +1,3 @@
+import { type Step } from "./index.js";
+declare const cleanupStep: Step;
+export default cleanupStep;

package/dist/steps/cleanup.js

@@ -0,0 +1,13 @@
+import { checkCommandExists, runStep } from "./index.js";
+const cleanupStep = {
+    id: "cleanup",
+    name: "Cleanup",
+    description: "Remove outdated Homebrew downloads and cached versions",
+    async checkIsAvailable() {
+        return checkCommandExists("brew");
+    },
+    async run(context) {
+        await runStep("brew cleanup", context);
+    },
+};
+export default cleanupStep;

package/dist/steps/dotnet.d.ts

@@ -0,0 +1,3 @@
+import { type Step } from "./index.js";
+declare const dotnetStep: Step;
+export default dotnetStep;

package/dist/steps/dotnet.js

@@ -0,0 +1,14 @@
+import { checkCommandExists, runStep } from "./index.js";
+const dotnetStep = {
+    id: "dotnet",
+    name: ".NET",
+    description: "Update all globally installed .NET tools",
+    // No brewPackageToInstall — .NET has its own installer
+    async checkIsAvailable() {
+        return checkCommandExists("dotnet");
+    },
+    async run(context) {
+        await runStep("dotnet tool update --global --all", context);
+    },
+};
+export default dotnetStep;

package/dist/steps/homebrew.d.ts

@@ -0,0 +1,3 @@
+import { type Step } from "./index.js";
+declare const homebrewStep: Step;
+export default homebrewStep;