argsbarg 4.1.0 → 5.0.1

package/src/install/install.test.ts

@@ -1,333 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { writeAppConfigFile } from "../config/file.ts";
-import type { CliProgram } from "../types.ts";
-import { detectInstalledArtifacts } from "./detect-installed.ts";
-import {
-  interactiveSelectionAssumesApp,
-  mergeInteractiveSelection,
-  parseInstallOpts,
-  runInstallMutation,
-  validateInstallOpts,
-} from "./index.ts";
-import { opencodeConfigDir } from "./mcp-opencode.ts";
-import { resolveClaudeDesktopMcpPath, resolveInstallPaths } from "./paths.ts";
-import { buildInstallPlan } from "./plan.ts";
-import { printInstallStatus, writeInteractiveInstallIntro } from "./status.ts";
-import { buildUninstallPlan } from "./uninstall.ts";
-
-const fixture: CliProgram = {
-  key: "testapp",
-  version: "0.0.0",
-  description: "Test",
-  mcpServer: { enabled: true },
-  handler: () => {},
-};
-
-let home: string;
-let prevHome: string | undefined;
-
-let prevXdg: string | undefined;
-
-beforeEach(() => {
-  home = mkdtempSync(join(tmpdir(), "argsbarg-install-"));
-  prevHome = process.env.HOME;
-  prevXdg = process.env.XDG_CONFIG_HOME;
-  process.env.HOME = home;
-  delete process.env.XDG_CONFIG_HOME;
-});
-
-afterEach(() => {
-  if (prevHome === undefined) delete process.env.HOME;
-  else process.env.HOME = prevHome;
-  if (prevXdg === undefined) delete process.env.XDG_CONFIG_HOME;
-  else process.env.XDG_CONFIG_HOME = prevXdg;
-  rmSync(home, { recursive: true, force: true });
-});
-
-describe("install paths", () => {
-  test("resolveInstallPaths uses ~/.local/bin for app", () => {
-    const paths = resolveInstallPaths(fixture);
-    expect(paths.appPath).toBe(join(home, ".local", "bin", "testapp"));
-  });
-
-  test("fish completion uses XDG_CONFIG_HOME", () => {
-    const xdg = join(home, "xdg");
-    process.env.XDG_CONFIG_HOME = xdg;
-    const paths = resolveInstallPaths(fixture);
-    expect(paths.fishCompletion).toBe(join(xdg, "fish", "completions", "testapp.fish"));
-  });
-
-  test("claude desktop mcp path on darwin", () => {
-    const prev = process.platform;
-    Object.defineProperty(process, "platform", { value: "darwin" });
-    try {
-      expect(resolveClaudeDesktopMcpPath(home)).toBe(
-        join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"),
-      );
-    } finally {
-      Object.defineProperty(process, "platform", { value: prev });
-    }
-  });
-});
-
-describe("detect installed", () => {
-  test("detects app and completions", () => {
-    const paths = resolveInstallPaths(fixture);
-    mkdirSync(paths.appDir, { recursive: true });
-    writeFileSync(paths.appPath, "fake", "utf8");
-    mkdirSync(join(home, ".bash_completion.d"), { recursive: true });
-    writeFileSync(paths.bashCompletion, "# bash", "utf8");
-
-    const detected = detectInstalledArtifacts(paths, fixture);
-    expect(detected.app).toBe(true);
-    expect(detected.bashCompletion).toBe(true);
-    expect(detected.zshCompletion).toBe(false);
-  });
-});
-
-describe("install plan", () => {
-  test("buildInstallPlan --all includes app", () => {
-    const paths = resolveInstallPaths(fixture);
-    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ all: "1" }));
-    expect(plan.some((a) => a.kind === "app")).toBe(true);
-  });
-
-  test("buildInstallPlan --mcp --yes also includes app", () => {
-    const paths = resolveInstallPaths(fixture);
-    const opts = parseInstallOpts({ mcp: "1", yes: "1" });
-    validateInstallOpts(opts);
-    const plan = buildInstallPlan(fixture, paths, opts);
-    expect(plan.some((a) => a.kind === "app")).toBe(true);
-  });
-
-  test("buildInstallPlan --mcp without yes omits app", () => {
-    const paths = resolveInstallPaths(fixture);
-    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ mcp: "1" }));
-    expect(plan.some((a) => a.kind === "app")).toBe(false);
-  });
-
-  test("buildInstallPlan --mcp skips MCP when agentIntegration is skill", () => {
-    const skillApp: CliProgram = {
-      ...fixture,
-      install: { agentIntegration: "skill" },
-    };
-    const paths = resolveInstallPaths(skillApp);
-    mkdirSync(join(home, ".claude"), { recursive: true });
-    mkdirSync(join(home, ".cursor"), { recursive: true });
-    const plan = buildInstallPlan(skillApp, paths, parseInstallOpts({ mcp: "1" }));
-    expect(plan.some((a) => a.kind.endsWith("-mcp"))).toBe(false);
-  });
-
-  test("buildInstallPlan --mcp includes claude desktop when app data exists", () => {
-    const paths = resolveInstallPaths(fixture);
-    mkdirSync(join(home, ".claude"), { recursive: true });
-    mkdirSync(join(home, "Library", "Application Support", "Claude"), { recursive: true });
-    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ mcp: "1" }));
-    expect(plan.some((a) => a.kind === "claude-desktop-mcp")).toBe(process.platform === "darwin");
-    expect(plan.some((a) => a.kind === "claude-mcp")).toBe(true);
-  });
-
-  test("buildInstallPlan --mcp skips claude desktop without app data", () => {
-    const paths = resolveInstallPaths(fixture);
-    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ mcp: "1" }));
-    expect(plan.some((a) => a.kind === "claude-desktop-mcp")).toBe(false);
-  });
-
-  test("buildInstallPlan --mcp includes opencode when config dir exists", () => {
-    const paths = resolveInstallPaths(fixture);
-    mkdirSync(opencodeConfigDir(home), { recursive: true });
-    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ mcp: "1" }));
-    expect(plan.some((a) => a.kind === "opencode-mcp")).toBe(true);
-  });
-
-  test("buildInstallPlan --mcp includes chatgpt when app data exists", () => {
-    const paths = resolveInstallPaths(fixture);
-    if (process.platform === "darwin") {
-      mkdirSync(join(home, "Library", "Application Support", "ChatGPT"), { recursive: true });
-      const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ mcp: "1" }));
-      expect(plan.some((a) => a.kind === "chatgpt-desktop-mcp")).toBe(true);
-    }
-  });
-});
-
-describe("install status", () => {
-  test("printInstallStatus human output", () => {
-    const paths = resolveInstallPaths(fixture);
-    mkdirSync(paths.appDir, { recursive: true });
-    writeFileSync(paths.appPath, "fake", "utf8");
-
-    const chunks: string[] = [];
-    const orig = process.stdout.write;
-    process.stdout.write = ((s: string) => {
-      chunks.push(s);
-      return true;
-    }) as typeof process.stdout.write;
-    try {
-      printInstallStatus(fixture, {});
-      const out = chunks.join("");
-      expect(out).toContain("Installed artifacts for testapp");
-      expect(out).toContain("~/.local/bin/testapp");
-    } finally {
-      process.stdout.write = orig;
-    }
-  });
-
-  test("printInstallStatus json output", () => {
-    const paths = resolveInstallPaths(fixture);
-    mkdirSync(join(home, ".cursor"), { recursive: true });
-    writeFileSync(
-      paths.cursorMcpPath,
-      JSON.stringify({ mcpServers: { testapp: { command: "testapp", args: ["mcp"] } } }),
-      "utf8",
-    );
-
-    const chunks: string[] = [];
-    const orig = process.stdout.write;
-    process.stdout.write = ((s: string) => {
-      chunks.push(s);
-      return true;
-    }) as typeof process.stdout.write;
-    try {
-      printInstallStatus(fixture, { json: true });
-      const data = JSON.parse(chunks.join(""));
-      expect(data.cursorMcp).toContain("mcp.json");
-    } finally {
-      process.stdout.write = orig;
-    }
-  });
-});
-
-describe("interactive selection", () => {
-  test("mergeInteractiveSelection prepends 1 when app is assumed", () => {
-    expect(mergeInteractiveSelection([2, 3], 5, true)).toEqual([1, 2, 3]);
-    expect(mergeInteractiveSelection([1, 3], 5, true)).toEqual([1, 3]);
-    expect(mergeInteractiveSelection([2, 3], 5, false)).toEqual([2, 3]);
-  });
-
-  test("interactiveSelectionAssumesApp when install plan starts with app", () => {
-    const paths = resolveInstallPaths(fixture);
-    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ all: "1" }));
-    expect(interactiveSelectionAssumesApp(plan, false)).toBe(true);
-    expect(interactiveSelectionAssumesApp(plan, true)).toBe(false);
-  });
-
-  test("interactiveSelectionAssumesApp false when app not in plan", () => {
-    const paths = resolveInstallPaths(fixture);
-    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ completions: "1" }));
-    expect(plan.some((a) => a.kind === "app")).toBe(false);
-    expect(interactiveSelectionAssumesApp(plan, false)).toBe(false);
-  });
-});
-
-describe("install output", () => {
-  test("writeInteractiveInstallIntro prints app Setup banner on stderr", () => {
-    const chunks: string[] = [];
-    const orig = process.stderr.write;
-    process.stderr.write = ((s: string | Uint8Array) => {
-      chunks.push(String(s));
-      return true;
-    }) as typeof process.stderr.write;
-    try {
-      writeInteractiveInstallIntro(fixture);
-      expect(chunks.join("")).toBe("\ntestapp Setup\n\n");
-    } finally {
-      process.stderr.write = orig;
-    }
-  });
-});
-
-describe("parseInstallOpts", () => {
-  test("json implies yes in validate path via cliInstall", () => {
-    const opts = parseInstallOpts({ json: "1", all: "1" });
-    expect(opts.json).toBe(true);
-    expect(opts.all).toBe(true);
-  });
-});
-
-describe("validateInstallOpts", () => {
-  test("uninstall requires a target flag", () => {
-    const opts = parseInstallOpts({ uninstall: "1", yes: "1" });
-    expect(validateInstallOpts(opts)).toContain("Specify at least one target");
-  });
-
-  test("uninstall allows --all", () => {
-    const opts = parseInstallOpts({ uninstall: "1", all: "1", yes: "1" });
-    expect(validateInstallOpts(opts)).toBeNull();
-  });
-
-  test("uninstall rejects --reinstall", () => {
-    const opts = parseInstallOpts({ uninstall: "1", reinstall: "1", all: "1" });
-    expect(validateInstallOpts(opts)).toContain("--reinstall");
-  });
-});
-
-describe("install mutation", () => {
-  test("uninstall --all with nothing installed succeeds", async () => {
-    const result = await runInstallMutation(fixture, { uninstall: "1", all: "1", yes: "1" });
-    expect(result.changed).toEqual([]);
-  });
-
-  test("install --skill skips cursor and claude when agent dirs missing", async () => {
-    const result = await runInstallMutation(fixture, { skill: "1", yes: "1", dry: "1" });
-    expect(
-      result.changed.every((p) => !p.includes("/.cursor/") && !p.includes("/.claude/skills/")),
-    ).toBe(true);
-  });
-
-  test("uninstall --all removes detected app", async () => {
-    const paths = resolveInstallPaths(fixture);
-    mkdirSync(paths.appDir, { recursive: true });
-    writeFileSync(paths.appPath, "fake", "utf8");
-
-    const result = await runInstallMutation(fixture, { uninstall: "1", all: "1", yes: "1" });
-    expect(result.changed).toContain(paths.appPath);
-    expect(existsSync(paths.appPath)).toBe(false);
-    expect(existsSync(paths.appDir)).toBe(true);
-  });
-});
-
-describe("uninstall plan", () => {
-  test("buildUninstallPlan --all scopes like install --all", () => {
-    const paths = resolveInstallPaths(fixture);
-    mkdirSync(paths.appDir, { recursive: true });
-    writeFileSync(paths.appPath, "fake", "utf8");
-
-    const plan = buildUninstallPlan(fixture, paths, parseInstallOpts({ uninstall: "1", all: "1" }));
-    expect(plan.some((a) => a.summary.startsWith("app:"))).toBe(true);
-  });
-
-  test("buildUninstallPlan --all runs configure last", () => {
-    const program: CliProgram = {
-      ...fixture,
-      appConfig: {
-        entries: { token: { description: "API token." } },
-      },
-    };
-    const paths = resolveInstallPaths(program);
-    mkdirSync(paths.appDir, { recursive: true });
-    writeFileSync(paths.appPath, "fake", "utf8");
-    writeAppConfigFile(program, { token: "secret" });
-
-    const plan = buildUninstallPlan(program, paths, parseInstallOpts({ uninstall: "1", all: "1" }));
-    const appIdx = plan.findIndex((a) => a.summary.startsWith("app:"));
-    const configureIdx = plan.findIndex((a) => a.summary.startsWith("app config:"));
-    expect(appIdx).toBeGreaterThanOrEqual(0);
-    expect(configureIdx).toBeGreaterThan(appIdx);
-    expect(configureIdx).toBe(plan.length - 1);
-  });
-
-  test("buildUninstallPlan --app ignores completions", () => {
-    const paths = resolveInstallPaths(fixture);
-    mkdirSync(paths.appDir, { recursive: true });
-    writeFileSync(paths.appPath, "fake", "utf8");
-    mkdirSync(join(home, ".bash_completion.d"), { recursive: true });
-    writeFileSync(paths.bashCompletion, "# bash", "utf8");
-
-    const plan = buildUninstallPlan(fixture, paths, parseInstallOpts({ uninstall: "1", app: "1" }));
-    expect(plan).toHaveLength(1);
-    expect(plan[0]?.summary.startsWith("app:")).toBe(true);
-  });
-});

package/src/install/targets/completions.ts

@@ -1,133 +0,0 @@
-import { existsSync } from "node:fs";
-import type { CliProgram } from "../../types.ts";
-import { installCompletions, uninstallCompletions } from "../completions.ts";
-import { displayInstallPath, type InstallPaths } from "../paths.ts";
-import { detectShells } from "../shell.ts";
-import { InstallTarget } from "../target-base.ts";
-import type {
-  DetectedSnapshot,
-  InstallAction,
-  InstalledArtifacts,
-  InstallStatus,
-  TargetPlanContext,
-  UninstallAction,
-} from "../target-types.ts";
-
-type ShellKind = "bash" | "zsh" | "fish";
-
-interface ShellCompletionSpec {
-  shell: ShellKind;
-  label: string;
-  path: (paths: InstallPaths) => string;
-  detectedKey: "bashCompletion" | "zshCompletion" | "fishCompletion";
-}
-
-const SHELLS: ShellCompletionSpec[] = [
-  {
-    shell: "bash",
-    label: "bash completion",
-    path: (p) => p.bashCompletion,
-    detectedKey: "bashCompletion",
-  },
-  {
-    shell: "zsh",
-    label: "zsh completion",
-    path: (p) => p.zshCompletion,
-    detectedKey: "zshCompletion",
-  },
-  {
-    shell: "fish",
-    label: "fish completion",
-    path: (p) => p.fishCompletion,
-    detectedKey: "fishCompletion",
-  },
-];
-
-/** Shell tab-completion scripts (bash / zsh / fish). */
-class CompletionsInstallTarget extends InstallTarget {
-  readonly key = "completions" as const;
-  readonly actionKind = "completions" as const;
-  readonly category = "core" as const;
-
-  isAvailable(_root: CliProgram, _paths: InstallPaths): boolean {
-    return true;
-  }
-
-  isDetected(paths: InstallPaths, _root: CliProgram): boolean {
-    return SHELLS.some((s) => existsSync(s.path(paths)));
-  }
-
-  applyDetected(paths: InstallPaths, _root: CliProgram, out: InstalledArtifacts): void {
-    for (const s of SHELLS) {
-      out[s.detectedKey] = existsSync(s.path(paths));
-    }
-  }
-
-  protected isDetectedFromSnapshot(detected: DetectedSnapshot): boolean {
-    return detected.bashCompletion || detected.zshCompletion || detected.fishCompletion;
-  }
-
-  protected formatStatusLine(_paths: InstallPaths, _root: CliProgram): string {
-    return "";
-  }
-
-  protected assignStatusLine(_status: InstallStatus, _line: string): void {}
-
-  contributeStatus(
-    paths: InstallPaths,
-    _root: CliProgram,
-    detected: InstalledArtifacts,
-    status: InstallStatus,
-  ): void {
-    if (detected.bashCompletion) {
-      status.bashCompletion = displayInstallPath(paths.bashCompletion);
-    }
-    if (detected.zshCompletion) {
-      status.zshCompletion = displayInstallPath(paths.zshCompletion);
-    }
-    if (detected.fishCompletion) {
-      status.fishCompletion = displayInstallPath(paths.fishCompletion);
-    }
-  }
-
-  protected buildInstallActions(ctx: TargetPlanContext): InstallAction[] {
-    const shells = detectShells();
-    const actions: InstallAction[] = [];
-    const refresh = ctx.mode === "refresh";
-
-    for (const s of SHELLS) {
-      const onPath = shells[s.shell];
-      const path = s.path(ctx.paths);
-      const wasInstalled = ctx.detected[s.detectedKey];
-      if (!onPath || (refresh && !wasInstalled)) continue;
-
-      actions.push({
-        kind: "completions",
-        summary: `${s.label}: ${displayInstallPath(path)}`,
-        message: `Writing ${s.label} to ${displayInstallPath(path)}`,
-        run: () => {
-          const all = installCompletions(ctx.root, ctx.paths, ctx.dry);
-          return all.filter((p) => p === path);
-        },
-      });
-    }
-    return actions;
-  }
-
-  protected buildUninstallActions(ctx: TargetPlanContext): UninstallAction[] {
-    const actions: UninstallAction[] = [];
-    for (const s of SHELLS) {
-      if (!ctx.detected[s.detectedKey]) continue;
-      const path = s.path(ctx.paths);
-      actions.push({
-        kind: "completions",
-        summary: `${s.label}: ${displayInstallPath(path)}`,
-        message: `Removing ${s.label} ${displayInstallPath(path)}`,
-        run: () => uninstallCompletions(ctx.paths, ctx.dry).filter((p) => p === path),
-      });
-    }
-    return actions;
-  }
-}
-
-export const completionsTarget = new CompletionsInstallTarget();

package/src/install/update.test.ts

@@ -1,123 +0,0 @@
-import { afterEach, beforeEach, expect, test } from "bun:test";
-import {
-  chmodSync,
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { cliPresentationRoot } from "../builtins/presentation.ts";
-import { Cli } from "../index.ts";
-import type { CliProgram, CliUpdateArtifact } from "../types.ts";
-import { cliValidateProgram } from "../validate.ts";
-import { parseInstallOpts, runInstallMutation } from "./index.ts";
-
-let home: string;
-let prevHome: string | undefined;
-let prevExecPath: string;
-
-beforeEach(() => {
-  home = mkdtempSync(join(tmpdir(), "argsbarg-update-"));
-  prevHome = process.env.HOME;
-  process.env.HOME = home;
-  prevExecPath = process.execPath;
-});
-
-afterEach(() => {
-  if (prevHome === undefined) delete process.env.HOME;
-  else process.env.HOME = prevHome;
-  process.execPath = prevExecPath;
-  rmSync(home, { recursive: true, force: true });
-});
-
-function fixtureWithUpdate(hook: () => Promise<CliUpdateArtifact>): CliProgram {
-  return {
-    key: "testapp",
-    version: "1.0.0",
-    description: "Test",
-    install: { updateGetLatest: hook },
-    commands: [{ key: "run", description: "Run", handler: () => {} }],
-  };
-}
-
-test("user update command is allowed when updateGetLatest is set", () => {
-  const root: CliProgram = {
-    ...fixtureWithUpdate(async () => ({ path: process.execPath })),
-    commands: [{ key: "update", description: "Custom update", handler: () => {} }],
-  };
-  expect(() => cliValidateProgram(root)).not.toThrow();
-});
-
-test("presentation exposes install --update when hook is set", () => {
-  const root = fixtureWithUpdate(async () => ({ path: process.execPath }));
-  const presentation = cliPresentationRoot(root);
-  const install = presentation.commands.find((c) => c.key === "install");
-  expect(install?.options?.some((o) => o.name === "update")).toBe(true);
-  expect(presentation.commands.some((c) => c.key === "update")).toBe(false);
-});
-
-test("parseInstallOpts treats --update separately from --reinstall", () => {
-  expect(parseInstallOpts({ update: "1" }).update).toBe(true);
-  expect(parseInstallOpts({ update: "1" }).reinstall).toBe(false);
-});
-
-test("runInstallMutation honors --from for binary copy", async () => {
-  const root: CliProgram = {
-    key: "testapp",
-    version: "1.0.0",
-    description: "Test",
-    handler: () => {},
-  };
-  const source = join(home, "new-binary");
-  writeFileSync(source, "#!/bin/sh\necho hi\n", "utf8");
-  chmodSync(source, 0o755);
-
-  const bindir = join(home, ".local", "bin");
-  mkdirSync(bindir, { recursive: true });
-  writeFileSync(join(bindir, "testapp"), "old\n", "utf8");
-
-  const { changed } = await runInstallMutation(root, {
-    reinstall: "1",
-    yes: "1",
-    from: source,
-  });
-
-  const dest = join(home, ".local", "bin", "testapp");
-  expect(changed).toContain(dest);
-  expect(readFileSync(dest, "utf8")).toContain("echo hi");
-});
-
-test("Cli.invoke install --update uses hook and reinstalls", async () => {
-  const source = join(home, "new-binary");
-  writeFileSync(source, "#!/bin/sh\necho hi\n", "utf8");
-  chmodSync(source, 0o755);
-
-  const root = fixtureWithUpdate(async () => ({
-    path: source,
-    version: "2.0.0",
-  }));
-
-  const bindir = join(home, ".local", "bin");
-  mkdirSync(bindir, { recursive: true });
-  writeFileSync(join(bindir, "testapp"), "old\n", "utf8");
-
-  const result = await new Cli(root).invoke(["install", "--update"]);
-  expect(result.exitCode).toBe(0);
-  expect(result.stdout).toContain("Updated testapp 1.0.0 → 2.0.0");
-  expect(existsSync(join(home, ".local", "bin", "testapp"))).toBe(true);
-});
-
-test("Cli.invoke install --update reports already current", async () => {
-  const root = fixtureWithUpdate(async () => ({
-    path: process.execPath,
-    version: "1.0.0",
-  }));
-
-  const result = await new Cli(root).invoke(["install", "--update"]);
-  expect(result.exitCode).toBe(0);
-  expect(result.stdout).toContain("Already at v1.0.0");
-});

package/src/install/update.ts

@@ -1,54 +0,0 @@
-import { existsSync } from "node:fs";
-import type { CliProgram } from "../types.ts";
-import { runInstallMutation } from "./index.ts";
-import { installErr } from "./status.ts";
-
-/** Downloads the latest release and reinstalls installed artifacts (`myapp install --update`). */
-export async function cliUpdate(root: CliProgram): Promise<never> {
-  const hook = root.install?.updateGetLatest;
-  if (!hook) {
-    installErr("Remote updates are not supported by this app.");
-    process.exit(1);
-  }
-
-  let artifact: Awaited<ReturnType<typeof hook>>;
-  try {
-    artifact = await hook({ version: root.version });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    installErr(message);
-    process.exit(1);
-  }
-
-  if (!artifact.path || !existsSync(artifact.path)) {
-    installErr("Update download did not return a valid app binary.");
-    process.exit(1);
-  }
-
-  if (artifact.version !== undefined && artifact.version === root.version) {
-    process.stdout.write(`Already at v${root.version}\n`);
-    await artifact.cleanup?.();
-    process.exit(0);
-  }
-
-  const currentVersion = root.version;
-  try {
-    await runInstallMutation(root, {
-      reinstall: "1",
-      yes: "1",
-      from: artifact.path,
-    });
-  } catch (err) {
-    await artifact.cleanup?.();
-    installErr(err instanceof Error ? err.message : String(err));
-    process.exit(1);
-  }
-
-  await artifact.cleanup?.();
-
-  if (artifact.version !== undefined && artifact.version !== currentVersion) {
-    process.stdout.write(`Updated ${root.key} ${currentVersion} → ${artifact.version}\n`);
-  }
-
-  process.exit(0);
-}