@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/cli/setup-model-picker.ts

@@ -0,0 +1,43 @@
+/**
+ * Standalone TUI model picker used by `prometheus setup speech`.
+ *
+ * Mirrors {@link ./session-picker.ts} for the standalone-TUI lifecycle: spin up
+ * a one-shot {@link TUI} over a {@link SelectList}, resolve on select/cancel, and
+ * tear the UI down. The standalone TUI auto-renders on input, so no manual
+ * render wiring is needed beyond `addChild`/`setFocus`/`start`.
+ */
+import { ProcessTerminal, type SelectItem, SelectList, TUI } from "@prometheus-ai/tui";
+import { getSelectListTheme } from "../modes/theme/theme";
+
+/**
+ * Show a single-column model picker and resolve with the chosen item's value,
+ * or `null` if the user cancelled. `currentValue` pre-selects the matching row.
+ */
+export async function selectSetupModel(
+	title: string,
+	items: SelectItem[],
+	currentValue: string,
+): Promise<string | null> {
+	const { promise, resolve } = Promise.withResolvers<string | null>();
+	const ui = new TUI(new ProcessTerminal());
+	let resolved = false;
+
+	const finish = (value: string | null): void => {
+		if (resolved) return;
+		resolved = true;
+		ui.stop();
+		resolve(value);
+	};
+
+	const list = new SelectList(items, Math.min(items.length, 10), getSelectListTheme());
+	const currentIndex = items.findIndex(item => item.value === currentValue);
+	if (currentIndex >= 0) list.setSelectedIndex(currentIndex);
+	list.onSelect = item => finish(item.value);
+	list.onCancel = () => finish(null);
+
+	process.stdout.write(`${title}\n`);
+	ui.addChild(list);
+	ui.setFocus(list);
+	ui.start();
+	return promise;
+}

package/src/cli/startup-cwd.ts

@@ -0,0 +1,68 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { getProjectDir, normalizePathForComparison, setProjectDir } from "@prometheus-ai/utils";
+import type { Args } from "./args";
+
+async function maybeAutoChdir(parsed: Args): Promise<void> {
+	if (parsed.allowHome || parsed.cwd) {
+		return;
+	}
+
+	const home = os.homedir();
+	if (!home) {
+		return;
+	}
+
+	const normalizePath = normalizePathForComparison;
+
+	const cwd = normalizePath(getProjectDir());
+	const normalizedHome = normalizePath(home);
+	if (cwd !== normalizedHome) {
+		return;
+	}
+
+	const isDirectory = async (p: string) => {
+		try {
+			const s = await fs.stat(p);
+			return s.isDirectory();
+		} catch {
+			return false;
+		}
+	};
+
+	const candidates = [path.join(home, "tmp"), "/tmp", "/var/tmp"];
+	for (const candidate of candidates) {
+		try {
+			if (!(await isDirectory(candidate))) {
+				continue;
+			}
+			setProjectDir(candidate);
+			return;
+		} catch {
+			// Try next candidate.
+		}
+	}
+
+	try {
+		const fallback = os.tmpdir();
+		if (fallback && normalizePath(fallback) !== cwd && (await isDirectory(fallback))) {
+			setProjectDir(fallback);
+		}
+	} catch {
+		// Ignore fallback errors.
+	}
+}
+
+export async function applyStartupCwd(parsed: Args): Promise<void> {
+	if (parsed.cwd) {
+		setProjectDir(parsed.cwd);
+		// setProjectDir resolves the (possibly relative) target against the launch
+		// cwd and chdirs into it. Re-sync parsed.cwd to the resolved absolute path
+		// so downstream consumers (buildSessionOptions, settings/discovery, session
+		// persistence) don't re-resolve a relative string against the new cwd.
+		parsed.cwd = getProjectDir();
+		return;
+	}
+	await maybeAutoChdir(parsed);
+}

package/src/cli/update-cli.ts

@@ -2,9 +2,10 @@
  * Update CLI command handler.
  *
  * Handles `prometheus update` to check for and install updates.
- * Uses bun if available, otherwise downloads binary from GitHub releases.
+ * Uses the installer that owns the active prometheus executable when it can be detected.
  */
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import { pipeline } from "node:stream/promises";
 import { $which, APP_NAME, isEnoent, VERSION } from "@prometheus-ai/utils";
@@ -14,6 +15,8 @@ import { theme } from "../modes/theme/theme";
 
 const REPO = "uttamtrivedi/Prometheus";
 const PACKAGE = "@prometheus-ai/agent";
+const HOMEBREW_FORMULA = "uttamtrivedi/tap/prometheus";
+const MISE_TOOL = "github:uttamtrivedi/Prometheus";
 /**
  * Official npm registry origin.
  *
@@ -54,16 +57,11 @@ function currentNativeTag(): string {
 	return `${process.platform}-${process.arch}`;
 }
 
-export interface ReleaseInfo {
+interface ReleaseInfo {
 	tag: string;
 	version: string;
 }
 
-export interface SourceUpdateInfo {
-	upstream?: string;
-	behind?: number;
-}
-
 /** Result from running the installed binary and parsing its reported version. */
 export interface InstalledVersionVerification {
 	ok: boolean;
@@ -80,11 +78,6 @@ export interface BinaryReplacementOptions {
 	verifyInstalledVersion: (expectedVersion: string) => Promise<InstalledVersionVerification>;
 }
 
-export interface SourceInstallCommand {
-	command: string;
-	args: string[];
-}
-
 /**
  * Parse update subcommand arguments.
  * Returns undefined if not an update command.
@@ -112,6 +105,46 @@ async function getBunGlobalBinDir(): Promise<string | undefined> {
 	}
 }
 
+async function getHomebrewFormulaPrefix(): Promise<string | undefined> {
+	if (!$which("brew")) return undefined;
+	for (const formula of [HOMEBREW_FORMULA, APP_NAME]) {
+		try {
+			const result = await $`brew --prefix ${formula}`.quiet().nothrow();
+			if (result.exitCode !== 0) continue;
+			const output = result.text().trim();
+			if (output.length > 0) return output;
+		} catch {}
+	}
+	return undefined;
+}
+
+async function getMiseBinDirs(): Promise<string[]> {
+	if (!$which("mise")) return [];
+	try {
+		const result = await $`mise bin-paths ${MISE_TOOL}`.quiet().nothrow();
+		if (result.exitCode !== 0) return [];
+		return result
+			.text()
+			.split(/\r?\n/)
+			.map(line => line.trim())
+			.filter(line => line.length > 0);
+	} catch {
+		return [];
+	}
+}
+
+function getMiseDataDir(): string {
+	const override = process.env.MISE_DATA_DIR;
+	if (override && override.length > 0) return override;
+	if (process.platform === "win32") {
+		const localAppData = process.env.LOCALAPPDATA;
+		if (localAppData && localAppData.length > 0) return path.join(localAppData, "mise");
+	}
+	const xdgDataHome = process.env.XDG_DATA_HOME;
+	if (xdgDataHome && xdgDataHome.length > 0) return path.join(xdgDataHome, "mise");
+	return path.join(os.homedir(), ".local", "share", "mise");
+}
+
 function normalizePathForComparison(filePath: string): string {
 	const normalized = path.normalize(filePath);
 	if (process.platform === "win32") return normalized.toLowerCase();
@@ -139,97 +172,65 @@ function isPathInDirectory(filePath: string, directoryPath: string): boolean {
 	// is a junction when Bun is installed via Scoop, so `bun pm bin -g` and the
 	// PATH-resolved prometheus path can refer to the same directory through different
 	// strings. path.resolve does not traverse junctions/symlinks; realpath does.
-	// Resolve the file's parent directory to tolerate the file itself not yet
-	// existing (e.g. a fresh install path) while still catching link-traversed
-	// equality once the directory exists.
-	const fileDir = tryRealpath(path.dirname(path.resolve(filePath)));
+	// Resolve both the file and its parent directory: the file catches manager
+	// links like Homebrew's `bin/prometheus -> Cellar/.../bin/prometheus`; the parent fallback
+	// still tolerates fresh install paths where the file does not exist yet.
 	const dirReal = tryRealpath(path.resolve(directoryPath));
-	if (!fileDir || !dirReal) return false;
+	if (!dirReal) return false;
+	const fileReal = tryRealpath(path.resolve(filePath));
+	if (fileReal && isPathInDirectoryLexical(fileReal, dirReal)) return true;
+	const fileDir = tryRealpath(path.dirname(path.resolve(filePath)));
+	if (!fileDir) return false;
 	const resolvedFile = path.join(fileDir, path.basename(filePath));
 	return isPathInDirectoryLexical(resolvedFile, dirReal);
 }
 
-export type UpdateTarget =
-	| { method: "source"; sourceDir: string }
-	| { method: "bun" }
-	| { method: "binary"; path: string };
-type UpdateOptions = { force: boolean; check: boolean };
-
-export interface UpdateCommandDependencies {
-	resolveUpdateTarget: () => Promise<UpdateTarget>;
-	getLatestRelease: () => Promise<ReleaseInfo>;
-	updateViaSource: (sourceDir: string, opts: UpdateOptions) => Promise<void>;
-	updateViaBun: (expectedVersion: string) => Promise<void>;
-	updateViaBinaryAt: (targetPath: string, expectedVersion: string) => Promise<void>;
-	exit: (code: number) => never;
-}
-
-function resolveUpdateMethod(ompPath: string, bunBinDir: string | undefined): "bun" | "binary" {
-	if (!bunBinDir) return "binary";
-	return isPathInDirectory(ompPath, bunBinDir) ? "bun" : "binary";
-}
-
-export function resolveUpdateMethodForTest(ompPath: string, bunBinDir: string | undefined): "bun" | "binary" {
-	return resolveUpdateMethod(ompPath, bunBinDir);
-}
+type UpdateMethod = "brew" | "mise" | "bun" | "binary";
 
-function isFile(filePath: string): boolean {
-	try {
-		return fs.statSync(filePath).isFile();
-	} catch {
-		return false;
-	}
+interface UpdateMethodResolutionOptions {
+	homebrewPrefix?: string;
+	miseBinDirs?: readonly string[];
+	miseDataDir?: string;
 }
 
-export function resolveSourceCheckoutFromPath(ompPath: string): string | undefined {
-	const realPath = tryRealpath(ompPath);
-	if (!realPath) return undefined;
+type UpdateTarget = { method: "brew" } | { method: "mise" } | { method: "bun" } | { method: "binary"; path: string };
 
-	const expectedSuffix = path.join("packages", "coding-agent", "src", "cli.ts");
-	const sourceDir = path.resolve(path.dirname(realPath), "..", "..", "..");
-	const relativeCliPath = normalizePathForComparison(path.relative(sourceDir, realPath));
-	if (relativeCliPath !== normalizePathForComparison(expectedSuffix)) return undefined;
-
-	if (
-		!isFile(path.join(sourceDir, "scripts", "install.sh")) ||
-		!isFile(path.join(sourceDir, "packages", "coding-agent", "package.json"))
-	) {
-		return undefined;
-	}
-
-	return sourceDir;
-}
-
-function resolveUpdateTargetFromPaths(
-	ompPath: string | undefined,
+function resolveUpdateMethod(
+	prometheusPath: string,
 	bunBinDir: string | undefined,
-): UpdateTarget | undefined {
-	if (ompPath) {
-		const sourceDir = resolveSourceCheckoutFromPath(ompPath);
-		if (sourceDir) return { method: "source", sourceDir };
-
-		const method = resolveUpdateMethod(ompPath, bunBinDir);
-		if (method === "bun") return { method };
-		return { method, path: ompPath };
-	}
-
-	if (bunBinDir) return { method: "bun" };
-	return undefined;
-}
-
-export function resolveUpdateTargetForTest(
-	ompPath: string | undefined,
+	options: UpdateMethodResolutionOptions = {},
+): UpdateMethod {
+	const { homebrewPrefix, miseBinDirs = [], miseDataDir } = options;
+	if (homebrewPrefix && isPathInDirectory(prometheusPath, path.join(homebrewPrefix, "bin"))) return "brew";
+	if (miseBinDirs.some(dir => isPathInDirectory(prometheusPath, dir))) return "mise";
+	if (miseDataDir && isPathInDirectory(prometheusPath, path.join(miseDataDir, "shims"))) return "mise";
+	if (bunBinDir && isPathInDirectory(prometheusPath, bunBinDir)) return "bun";
+	return "binary";
+}
+
+export function resolveUpdateMethodForTest(
+	prometheusPath: string,
 	bunBinDir: string | undefined,
-): UpdateTarget | undefined {
-	return resolveUpdateTargetFromPaths(ompPath, bunBinDir);
+	options: UpdateMethodResolutionOptions = {},
+): UpdateMethod {
+	return resolveUpdateMethod(prometheusPath, bunBinDir, options);
 }
-
 async function resolveUpdateTarget(): Promise<UpdateTarget> {
 	const bunBinDir = await getBunGlobalBinDir();
-	const ompPath = resolveOmpPath();
+	const homebrewPrefix = await getHomebrewFormulaPrefix();
+	const miseAvailable = $which("mise") !== undefined;
+	const miseBinDirs = miseAvailable ? await getMiseBinDirs() : [];
+	const miseDataDir = miseAvailable ? getMiseDataDir() : undefined;
+	const prometheusPath = resolvePrometheusPath();
+
+	if (prometheusPath) {
+		const method = resolveUpdateMethod(prometheusPath, bunBinDir, { homebrewPrefix, miseBinDirs, miseDataDir });
+		if (method === "binary") return { method, path: prometheusPath };
+		return { method };
+	}
+
+	if (bunBinDir) return { method: "bun" };
 
-	const target = resolveUpdateTargetFromPaths(ompPath, bunBinDir);
-	if (target) return target;
 	throw new Error(`Could not resolve ${APP_NAME} binary path in PATH`);
 }
 
@@ -314,7 +315,7 @@ function getBinaryName(): string {
 /**
  * Resolve the path that `prometheus` maps to in the user's PATH.
  */
-function resolveOmpPath(): string | undefined {
+function resolvePrometheusPath(): string | undefined {
 	return $which(APP_NAME) ?? undefined;
 }
 
@@ -322,18 +323,18 @@ function resolveOmpPath(): string | undefined {
  * Run the resolved prometheus binary and check if it reports the expected version.
  */
 async function verifyInstalledVersion(expectedVersion: string): Promise<InstalledVersionVerification> {
-	const ompPath = resolveOmpPath();
-	if (!ompPath) return { ok: false };
+	const prometheusPath = resolvePrometheusPath();
+	if (!prometheusPath) return { ok: false };
 	try {
-		const result = await $`${ompPath} --version`.quiet().nothrow();
-		if (result.exitCode !== 0) return { ok: false, path: ompPath };
+		const result = await $`${prometheusPath} --version`.quiet().nothrow();
+		if (result.exitCode !== 0) return { ok: false, path: prometheusPath };
 		const output = result.text().trim();
 		// Output format: "prometheus/X.Y.Z"
 		const match = output.match(/\/(\d+\.\d+\.\d+)/);
 		const actual = match?.[1];
-		return { ok: actual === expectedVersion, actual, path: ompPath };
+		return { ok: actual === expectedVersion, actual, path: prometheusPath };
 	} catch {
-		return { ok: false, path: ompPath };
+		return { ok: false, path: prometheusPath };
 	}
 }
 
@@ -358,14 +359,7 @@ async function printVerification(expectedVersion: string): Promise<void> {
 		return;
 	}
 	console.log(chalk.yellow(`\nWarning: ${formatVerificationFailure(result, expectedVersion)}`));
-	console.log(chalk.yellow(`You may need to reinstall: ${getInstallCommand()}`));
-}
-
-function getInstallCommand(): string {
-	if (process.platform === "win32") {
-		return "irm https://raw.githubusercontent.com/uttamtrivedi/Prometheus/main/scripts/install.ps1 | iex";
-	}
-	return "curl -fsSL https://raw.githubusercontent.com/uttamtrivedi/Prometheus/main/scripts/install.sh | sh";
+	console.log(chalk.yellow(`You may need to reinstall: curl -fsSL https://prometheus.sh/install | sh`));
 }
 
 async function unlinkIfExists(filePath: string): Promise<void> {
@@ -452,6 +446,18 @@ export function buildBunInstallArgs(expectedVersion: string, nativeTag: string =
 	return args;
 }
 
+export function buildHomebrewUpdateArgs(force: boolean): string[] {
+	return [force ? "reinstall" : "upgrade", HOMEBREW_FORMULA];
+}
+
+export function buildMiseUpgradeArgs(): string[] {
+	return ["upgrade", MISE_TOOL, "--bump"];
+}
+
+export function buildMiseForceInstallArgs(expectedVersion: string): string[] {
+	return ["install", "--force", `${MISE_TOOL}@${expectedVersion}`];
+}
+
 /**
  * Update via bun package manager.
  */
@@ -466,141 +472,40 @@ async function updateViaBun(expectedVersion: string): Promise<void> {
 	await printVerification(expectedVersion);
 }
 
-async function getGitUpstream(sourceDir: string): Promise<string | undefined> {
-	const result = await $`git rev-parse --abbrev-ref --symbolic-full-name "@{u}"`.cwd(sourceDir).quiet().nothrow();
-	if (result.exitCode !== 0) return undefined;
-	const upstream = result.text().trim();
-	return upstream.length > 0 ? upstream : undefined;
-}
-
-async function hasTrackedChanges(sourceDir: string): Promise<boolean> {
-	const result = await $`git status --porcelain --untracked-files=no`.cwd(sourceDir).quiet().nothrow();
-	if (result.exitCode !== 0) return false;
-	return result.text().trim().length > 0;
-}
-
-export async function getSourceUpdateInfo(sourceDir: string): Promise<SourceUpdateInfo> {
-	const upstream = await getGitUpstream(sourceDir);
-	if (!upstream) return {};
-
-	const fetchResult = await $`git fetch --quiet`.cwd(sourceDir).nothrow();
-	if (fetchResult.exitCode !== 0) return { upstream };
-
-	const range = `HEAD..${upstream}`;
-	const behindResult = await $`git rev-list --count ${range}`.cwd(sourceDir).quiet().nothrow();
-	if (behindResult.exitCode !== 0) return { upstream };
-
-	const behind = Number.parseInt(behindResult.text().trim(), 10);
-	return { upstream, behind: Number.isFinite(behind) ? behind : 0 };
-}
-
-async function checkSourceUpstream(sourceDir: string, upstream: string): Promise<void> {
-	const fetchResult = await $`git fetch --quiet`.cwd(sourceDir).nothrow();
-	if (fetchResult.exitCode !== 0) {
-		console.log(chalk.yellow(`Could not fetch ${upstream}; source checkout was not checked against upstream.`));
-		return;
-	}
-
-	const range = `HEAD..${upstream}`;
-	const behindResult = await $`git rev-list --count ${range}`.cwd(sourceDir).quiet().nothrow();
-	if (behindResult.exitCode !== 0) {
-		console.log(chalk.yellow(`Could not compare local checkout with ${upstream}.`));
-		return;
-	}
-
-	const behind = Number.parseInt(behindResult.text().trim(), 10);
-	if (behind > 0) {
-		console.log(chalk.cyan(`${behind} upstream commit${behind === 1 ? "" : "s"} available from ${upstream}`));
-		return;
+async function updateViaHomebrew(expectedVersion: string, force: boolean): Promise<void> {
+	console.log(chalk.dim("Updating Homebrew formulae..."));
+	const update = await $`brew update`.nothrow();
+	if (update.exitCode !== 0) {
+		throw new Error(`brew update failed with exit code ${update.exitCode}`);
 	}
 
-	console.log(chalk.green(`${theme.status.success} Source checkout is up to date with ${upstream}`));
-}
-
-async function pullSourceIfPossible(sourceDir: string, upstream: string | undefined): Promise<void> {
-	if (!upstream) {
-		console.log(chalk.dim("No upstream branch configured; refreshing the local source checkout."));
-		return;
-	}
-
-	if (await hasTrackedChanges(sourceDir)) {
-		console.log(
-			chalk.yellow("Tracked local changes detected; skipping git pull and refreshing the current checkout."),
-		);
-		return;
+	console.log(chalk.dim("Updating via Homebrew..."));
+	const args = buildHomebrewUpdateArgs(force);
+	const result = await $`brew ${args}`.nothrow();
+	if (result.exitCode !== 0) {
+		throw new Error(`brew ${args[0]} failed with exit code ${result.exitCode}`);
 	}
 
-	console.log(chalk.dim(`Fast-forwarding source checkout from ${upstream}...`));
-	const pullResult = await $`git pull --ff-only`.cwd(sourceDir).nothrow();
-	if (pullResult.exitCode !== 0) {
-		throw new Error(`git pull --ff-only failed with exit code ${pullResult.exitCode}`);
-	}
+	await printVerification(expectedVersion);
 }
 
-type CommandResolver = (command: string) => string | null;
-
-function resolveSourceInstallCommand(
-	sourceDir: string,
-	platform: NodeJS.Platform = process.platform,
-	resolveCommand: CommandResolver = $which,
-): SourceInstallCommand {
-	if (platform === "win32") {
-		const shell = resolveCommand("pwsh") ?? resolveCommand("powershell.exe") ?? resolveCommand("powershell");
-		if (!shell) {
-			throw new Error("PowerShell is required to refresh a Windows source install");
-		}
-		return {
-			command: shell,
-			args: [
-				"-NoProfile",
-				"-ExecutionPolicy",
-				"Bypass",
-				"-File",
-				path.join(sourceDir, "scripts", "install.ps1"),
-				"-Source",
-			],
-		};
+async function updateViaMise(expectedVersion: string, force: boolean): Promise<void> {
+	console.log(chalk.dim("Updating via mise..."));
+	const args = buildMiseUpgradeArgs();
+	const result = await $`mise ${args}`.nothrow();
+	if (result.exitCode !== 0) {
+		throw new Error(`mise upgrade failed with exit code ${result.exitCode}`);
 	}
 
-	return {
-		command: "sh",
-		args: [path.join(sourceDir, "scripts", "install.sh"), "--source"],
-	};
-}
-
-export function resolveSourceInstallCommandForTest(
-	sourceDir: string,
-	platform: NodeJS.Platform,
-	resolveCommand: CommandResolver,
-): SourceInstallCommand {
-	return resolveSourceInstallCommand(sourceDir, platform, resolveCommand);
-}
-
-async function updateViaSource(sourceDir: string, opts: { check: boolean }): Promise<void> {
-	console.log(chalk.dim(`Detected source checkout: ${sourceDir}`));
-	const upstream = await getGitUpstream(sourceDir);
-
-	if (opts.check) {
-		if (!upstream) {
-			console.log(chalk.green(`${theme.status.success} Source checkout install is active`));
-			console.log(chalk.dim("No upstream branch is configured, so update will refresh the local checkout only."));
-			return;
+	if (force) {
+		const forceArgs = buildMiseForceInstallArgs(expectedVersion);
+		const forceResult = await $`mise ${forceArgs}`.nothrow();
+		if (forceResult.exitCode !== 0) {
+			throw new Error(`mise install --force failed with exit code ${forceResult.exitCode}`);
 		}
-		await checkSourceUpstream(sourceDir, upstream);
-		return;
 	}
 
-	await pullSourceIfPossible(sourceDir, upstream);
-
-	console.log(chalk.dim("Refreshing source install..."));
-	const installCommand = resolveSourceInstallCommand(sourceDir);
-	const result = await $`${installCommand.command} ${installCommand.args}`.cwd(sourceDir).nothrow();
-	if (result.exitCode !== 0) {
-		throw new Error(`source install failed with exit code ${result.exitCode}`);
-	}
-
-	console.log(chalk.green(`\n${theme.status.success} Source install refreshed`));
-	console.log(chalk.dim(`Restart ${APP_NAME} to use the refreshed checkout`));
+	await printVerification(expectedVersion);
 }
 
 /**
@@ -634,53 +539,19 @@ async function updateViaBinaryAt(targetPath: string, expectedVersion: string): P
 	console.log(chalk.dim(`Restart ${APP_NAME} to use the new version`));
 }
 
-function exitProcess(code: number): never {
-	process.exit(code);
-}
-
-const defaultUpdateCommandDependencies: UpdateCommandDependencies = {
-	resolveUpdateTarget,
-	getLatestRelease,
-	updateViaSource,
-	updateViaBun,
-	updateViaBinaryAt,
-	exit: exitProcess,
-};
-
 /**
  * Run the update command.
  */
-export async function runUpdateCommandWithDependencies(
-	opts: UpdateOptions,
-	deps: UpdateCommandDependencies,
-): Promise<void> {
+export async function runUpdateCommand(opts: { force: boolean; check: boolean }): Promise<void> {
 	console.log(chalk.dim(`Current version: ${VERSION}`));
 
-	let target: UpdateTarget;
-	try {
-		target = await deps.resolveUpdateTarget();
-	} catch (err) {
-		console.error(chalk.red(`Update failed: ${err}`));
-		deps.exit(1);
-	}
-
-	if (target.method === "source") {
-		try {
-			await deps.updateViaSource(target.sourceDir, opts);
-		} catch (err) {
-			console.error(chalk.red(`Update failed: ${err}`));
-			deps.exit(1);
-		}
-		return;
-	}
-
 	// Check for updates
 	let release: ReleaseInfo;
 	try {
-		release = await deps.getLatestRelease();
+		release = await getLatestRelease();
 	} catch (err) {
 		console.error(chalk.red(`Failed to check for updates: ${err}`));
-		deps.exit(1);
+		process.exit(1);
 	}
 
 	const comparison = compareVersions(release.version, VERSION);
@@ -703,21 +574,22 @@ export async function runUpdateCommandWithDependencies(
 
 	// Choose update method based on the prioritized prometheus binary in PATH
 	try {
-		if (target.method === "bun") {
-			await deps.updateViaBun(release.version);
+		const target = await resolveUpdateTarget();
+		if (target.method === "brew") {
+			await updateViaHomebrew(release.version, opts.force);
+		} else if (target.method === "mise") {
+			await updateViaMise(release.version, opts.force);
+		} else if (target.method === "bun") {
+			await updateViaBun(release.version);
 		} else {
-			await deps.updateViaBinaryAt(target.path, release.version);
+			await updateViaBinaryAt(target.path, release.version);
 		}
 	} catch (err) {
 		console.error(chalk.red(`Update failed: ${err}`));
-		deps.exit(1);
+		process.exit(1);
 	}
 }
 
-export async function runUpdateCommand(opts: UpdateOptions): Promise<void> {
-	await runUpdateCommandWithDependencies(opts, defaultUpdateCommandDependencies);
-}
-
 /**
  * Print update command help.
  */