@visulima/vis 1.0.0-alpha.1 → 1.0.0-alpha.11

package/dist/packem_chunks/handler34.js

@@ -0,0 +1,630 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  execSync
+} = __cjs_getBuiltinModule("node:child_process");
+import { yellow, red } from '@visulima/colorize';
+import { isAccessibleSync, readJsonSync } from '@visulima/fs';
+import { readYamlSync } from '@visulima/fs/yaml';
+import { findPackageManagerSync, getPackageManagerVersion } from '@visulima/package';
+import { join } from '@visulima/path';
+import { render, renderToString, Text } from '@visulima/tui';
+import { K as resolveAubeUpdate, r as resolveInstaller, i as isInCi, j as scoreColor, a as buildSocketOptions } from './bin.js';
+import React from 'react';
+import { v as validateAnalysisType, r as runAiAnalysis, f as formatAiAnalysis } from '../packem_shared/ai-analysis-CHeB1joD.js';
+import { r as runTyposquatCheck, s as scanDepsForTyposquats } from '../packem_shared/typosquats-C-bCh3PX.js';
+import { U as UpdateStore, V as VisUpdateApp, C as CheckProgressApp } from '../packem_shared/VisUpdateApp-D-Yz_wvg.js';
+import { i as hasBackup, j as restoreFromBackup, k as hasCatalogs, l as loadNpmrc, r as readCatalogs, c as checkOutdated, m as fetchChangelogInfo, b as formatSummary, n as promptPackageSelection, t as toFilterArray, o as applyCatalogUpdates, q as formatOutdatedJson, d as formatOutdatedMinimal, h as formatOutdatedTable } from '../packem_shared/catalog-BJTtyi-O.js';
+import { p as parsePackageArgument } from '../packem_shared/utils-CthVdBPS.js';
+
+const resolvePnpm = (options) => {
+  const args = [];
+  for (const filter of options.filters) {
+    args.push("--filter", filter);
+  }
+  if (options.workspaceRoot) {
+    args.push("--filter", ".");
+  }
+  args.push("update");
+  if (options.latest) {
+    args.push("--latest");
+  }
+  if (options.recursive) {
+    args.push("--recursive");
+  }
+  if (options.interactive) {
+    args.push("--interactive");
+  }
+  if (options.dev) {
+    args.push("--dev");
+  }
+  if (options.prod) {
+    args.push("--prod");
+  }
+  if (options.noOptional) {
+    args.push("--no-optional");
+  }
+  if (options.noSave) {
+    args.push("--no-save");
+  }
+  args.push(...options.packages);
+  return { args, bin: "pnpm" };
+};
+const resolveYarnV1 = (options) => {
+  const args = [];
+  if (options.filters.length > 0) {
+    args.push("workspace", options.filters[0]);
+  }
+  args.push("upgrade");
+  if (options.latest) {
+    args.push("--latest");
+  }
+  args.push(...options.packages);
+  return { args, bin: "yarn" };
+};
+const resolveYarnBerry = (options) => {
+  const args = [];
+  if (options.filters.length > 0 || options.recursive) {
+    args.push("workspaces", "foreach", "--all");
+    for (const filter of options.filters) {
+      args.push("--include", filter);
+    }
+  }
+  args.push("up");
+  if (options.interactive) {
+    args.push("--interactive");
+  }
+  args.push(...options.packages);
+  return { args, bin: "yarn" };
+};
+const resolveNpm = (options, warnings) => {
+  const args = ["update"];
+  if (options.latest) {
+    warnings.push("npm does not support --latest flag. Packages will be updated within their semver range.");
+  }
+  if (options.interactive) {
+    warnings.push("npm does not support --interactive mode.");
+  }
+  for (const filter of options.filters) {
+    args.push("--workspace", filter);
+  }
+  if (options.recursive) {
+    args.push("--workspaces");
+  }
+  if (options.workspaceRoot) {
+    args.push("--include-workspace-root");
+  }
+  if (options.dev) {
+    args.push("--dev");
+  }
+  if (options.prod) {
+    args.push("--production");
+  }
+  if (options.noOptional) {
+    args.push("--no-optional");
+  }
+  if (options.noSave) {
+    args.push("--no-save");
+  }
+  args.push(...options.packages);
+  return { args, bin: "npm" };
+};
+const resolveBun = (options) => {
+  const args = ["update"];
+  if (options.latest) {
+    args.push("--latest");
+  }
+  for (const filter of options.filters) {
+    args.push("--filter", filter);
+  }
+  args.push(...options.packages);
+  return { args, bin: "bun" };
+};
+const resolveUpdateCommand = (packageManager, version, options) => {
+  const warnings = [];
+  if (options.global && packageManager !== "aube") {
+    const args = ["update", "--global", ...options.packages];
+    return { command: { args, bin: "npm" }, warnings };
+  }
+  let command;
+  switch (packageManager) {
+    case "aube": {
+      const aube = resolveAubeUpdate(options);
+      command = { args: aube.args, bin: aube.bin };
+      warnings.push(...aube.warnings);
+      break;
+    }
+    case "bun": {
+      command = resolveBun(options);
+      break;
+    }
+    case "npm": {
+      command = resolveNpm(options, warnings);
+      break;
+    }
+    case "pnpm": {
+      command = resolvePnpm(options);
+      break;
+    }
+    case "yarn": {
+      command = version.startsWith("1.") ? resolveYarnV1(options) : resolveYarnBerry(options);
+      break;
+    }
+    default: {
+      const exhaustiveCheck = packageManager;
+      throw new Error(`Unsupported package manager: ${String(exhaustiveCheck)}`);
+    }
+  }
+  return { command, warnings };
+};
+
+const readPmNativeMinimumReleaseAge = (workspaceRoot, packageManager) => {
+  try {
+    if (packageManager === "pnpm") {
+      const yamlPath = join(workspaceRoot, "pnpm-workspace.yaml");
+      if (isAccessibleSync(yamlPath)) {
+        const data = readYamlSync(yamlPath);
+        if (typeof data?.minimumReleaseAge === "number") {
+          return data.minimumReleaseAge;
+        }
+      }
+    } else if (packageManager === "bun") {
+      const pkgPath = join(workspaceRoot, "package.json");
+      if (isAccessibleSync(pkgPath)) {
+        const pkg = readJsonSync(pkgPath);
+        if (typeof pkg.minimumReleaseAge === "number") {
+          return pkg.minimumReleaseAge;
+        }
+      }
+    }
+  } catch {
+  }
+  return void 0;
+};
+const buildCatalogCheckOptions = (options, configDefaults, argument) => {
+  const target = options.latest ? "latest" : options.target ?? configDefaults.target ?? "latest";
+  if (!["latest", "minor", "patch"].includes(target)) {
+    throw new Error(`Invalid target "${target}". Use: latest, minor, or patch.`);
+  }
+  return {
+    exclude: [...toFilterArray(options.exclude), ...toFilterArray(configDefaults.exclude)],
+    ignore: toFilterArray(configDefaults.ignore),
+    include: [...toFilterArray(options.include), ...toFilterArray(configDefaults.include), ...argument],
+    includeLocked: options.includeLocked || configDefaults.includeLocked || false,
+    includePrerelease: options.prerelease || configDefaults.prerelease || false,
+    minimumReleaseAge: configDefaults.minimumReleaseAge,
+    minimumReleaseAgeExclude: configDefaults.minimumReleaseAgeExclude,
+    packageMode: configDefaults.packageMode,
+    security: options.security || options.ai || configDefaults.security || false,
+    target
+  };
+};
+const logFilteredByTarget = (entries, logger) => {
+  if (entries.length === 0) {
+    return;
+  }
+  logger.info(
+    `
+${yellow("⚠")} ${String(entries.length)} package${entries.length === 1 ? "" : "s"} skipped by target constraint (use --target latest to include):`
+  );
+  for (const entry of entries) {
+    logger.info(`    ${entry.packageName}  ${entry.currentRange} → ${entry.newRange}  (${entry.updateType})`);
+  }
+};
+const writeFormattedOutput = (entries, failed, format, logger) => {
+  if (format === "json") {
+    process.stdout.write(`${formatOutdatedJson({ checkedCount: 0, failed, filteredByTarget: [], ignored: [], outdated: entries })}
+`);
+  } else if (format === "minimal") {
+    process.stdout.write(`${formatOutdatedMinimal(entries)}
+`);
+  } else {
+    formatOutdatedTable(entries, logger);
+    logger.info(formatSummary(entries));
+  }
+};
+const applyCatalogAndInstall = async (workspaceRoot, packageManager, toApply, options, logger) => {
+  const backupPath = applyCatalogUpdates(workspaceRoot, toApply, packageManager);
+  const targetFile = packageManager === "pnpm" ? "pnpm-workspace.yaml" : "package.json";
+  logger.info(`
+Updated ${targetFile}`);
+  if (backupPath) {
+    logger.info(`Backup saved to ${backupPath}`);
+  }
+  if (options.changelog) {
+    logger.info("\nFetching changelogs...");
+    const changelogs = await fetchChangelogInfo(toApply);
+    for (const info of changelogs) {
+      const url = info.releaseUrl ?? info.repoUrl ?? info.npmUrl;
+      logger.info(`  ${info.packageName}: ${url}`);
+    }
+  }
+  if (options.install ?? true) {
+    const installCommands = {
+      bun: "bun install",
+      npm: "npm install",
+      pnpm: "pnpm install",
+      yarn: "yarn install"
+    };
+    const installCommand = installCommands[packageManager] ?? `${packageManager} install`;
+    logger.info(`Running ${installCommand}...
+`);
+    try {
+      execSync(installCommand, {
+        cwd: workspaceRoot,
+        env: process.env,
+        stdio: "inherit"
+      });
+    } catch {
+      logger.warn(`${installCommand} failed. You may need to run it manually.`);
+    }
+  }
+};
+const executeCatalogUpdate = async (workspaceRoot, packageManager, visConfig, options, argument, logger) => {
+  const configDefaults = visConfig.update ?? {};
+  const ignoredCatalogFlags = [
+    ["global", "--global is not supported in catalog mode"],
+    ["recursive", "--recursive is not needed in catalog mode (catalogs are workspace-level)"],
+    ["filter", "--filter is not supported in catalog mode (use --include/--exclude instead)"],
+    ["no-save", "--no-save is not supported in catalog mode"],
+    ["workspace-root", "--workspace-root is not needed in catalog mode"],
+    ["no-optional", "--no-optional is not supported in catalog mode"]
+  ];
+  for (const [flag, message] of ignoredCatalogFlags) {
+    if (options[flag]) {
+      logger.warn(`${yellow("⚠")} ${message}, ignoring.`);
+    }
+  }
+  const pmNativeAge = readPmNativeMinimumReleaseAge(workspaceRoot, packageManager);
+  const effectiveAge = configDefaults.minimumReleaseAge ?? pmNativeAge;
+  if (configDefaults.minimumReleaseAge !== void 0 && pmNativeAge !== void 0 && configDefaults.minimumReleaseAge !== pmNativeAge) {
+    const pmConfigFile = packageManager === "pnpm" ? "pnpm-workspace.yaml" : "package.json";
+    logger.warn(
+      `${yellow("⚠")} minimumReleaseAge mismatch: vis config = ${String(configDefaults.minimumReleaseAge)} min, ${pmConfigFile} = ${String(pmNativeAge)} min. Consider keeping them in sync.`
+    );
+  }
+  const npmrcConfig = loadNpmrc(workspaceRoot);
+  const catalogs = readCatalogs(workspaceRoot, packageManager, {
+    depFields: configDefaults.depFields,
+    dev: options.dev,
+    prod: options.prod
+  });
+  if (catalogs.size === 0) {
+    logger.info("No catalogs found.");
+    return;
+  }
+  const resolvedDefaults = { ...configDefaults, minimumReleaseAge: effectiveAge };
+  const checkOptions = buildCatalogCheckOptions(options, resolvedDefaults, argument);
+  let totalDeps = 0;
+  for (const deps of catalogs.values()) {
+    totalDeps += deps.size;
+  }
+  const isTTY = Boolean(process.stdout.isTTY) && !isInCi;
+  let progressInstance;
+  const onProgress = isTTY ? (current, total) => {
+    if (progressInstance) {
+      progressInstance.rerender(React.createElement(CheckProgressApp, { current, total }));
+    } else {
+      process.stdout.write("\n");
+      progressInstance = render(React.createElement(CheckProgressApp, { current, total }), {
+        interactive: true,
+        patchConsole: false
+      });
+    }
+  } : (current, total) => {
+    logger.info(`Checking ${String(current)}/${String(total)} dependencies...`);
+  };
+  if (!isTTY) {
+    logger.info(`Checking ${String(totalDeps)} catalog dependencies...
+`);
+  }
+  const socketOptions = buildSocketOptions(visConfig.security?.socket);
+  const { checkedCount, failed, filteredByTarget, ignored, outdated } = await checkOutdated(
+    catalogs,
+    checkOptions,
+    npmrcConfig,
+    onProgress,
+    workspaceRoot,
+    socketOptions,
+    visConfig.security?.socket?.acceptedRisks
+  );
+  if (progressInstance) {
+    progressInstance.clear();
+    progressInstance.unmount();
+  }
+  const upToDate = checkedCount - outdated.length - failed.length;
+  if (failed.length > 0) {
+    logger.warn(`Failed to fetch: ${failed.join(", ")}`);
+  }
+  if (ignored.length > 0) {
+    logger.info(`Skipped ${String(ignored.length)} ignored package${ignored.length === 1 ? "" : "s"}: ${ignored.join(", ")}`);
+  }
+  if (!isTTY && checkedCount > outdated.length) {
+    const totalCatalogEntries = [...catalogs.values()].reduce((sum, deps) => sum + deps.size, 0);
+    const dedupeNote = totalCatalogEntries > checkedCount ? ` (${String(totalCatalogEntries)} catalog entries, ${String(totalCatalogEntries - checkedCount)} duplicates)` : "";
+    logger.info(
+      `Checked ${String(checkedCount)} unique packages${dedupeNote}: ${String(outdated.length)} outdated, ${String(upToDate)} up-to-date${failed.length > 0 ? `, ${String(failed.length)} failed` : ""}${filteredByTarget.length > 0 ? `, ${String(filteredByTarget.length)} skipped by target` : ""}`
+    );
+  }
+  if (outdated.length === 0) {
+    if (filteredByTarget.length > 0) {
+      logger.info(
+        `All catalog dependencies are up to date within the current target.
+${String(filteredByTarget.length)} package${filteredByTarget.length === 1 ? " has" : "s have"} newer versions available with --target latest:
+${filteredByTarget.map((e) => `  ${e.packageName}  ${e.currentRange} → ${e.newRange}  (${e.updateType})`).join("\n")}`
+      );
+    } else {
+      logger.info("All catalog dependencies are up to date.");
+    }
+    return;
+  }
+  const format = options.format ?? configDefaults.format ?? "table";
+  let aiResult;
+  if (options.ai) {
+    const analysisType = validateAnalysisType(options.aiType ?? "impact");
+    aiResult = await runAiAnalysis(outdated, logger, visConfig.ai, analysisType);
+  }
+  const isDryRun = Boolean(options.dryRun);
+  if (isTTY && format === "table") {
+    const store = new UpdateStore(outdated, aiResult ?? null);
+    let changelogUrls;
+    if (options.changelog) {
+      logger.info("Fetching changelogs...");
+      const changelogs = await fetchChangelogInfo(outdated);
+      changelogUrls = /* @__PURE__ */ new Map();
+      for (const info of changelogs) {
+        const url = info.releaseUrl ?? info.repoUrl ?? info.npmUrl;
+        if (url) {
+          changelogUrls.set(info.packageName, url);
+        }
+      }
+    }
+    const autoExitConfig = visConfig.tui?.autoExit ?? false;
+    const autoExitSeconds = autoExitConfig === true ? 3 : typeof autoExitConfig === "number" ? autoExitConfig : 0;
+    const instance = render(
+      React.createElement(VisUpdateApp, {
+        autoExitSeconds,
+        changelogUrls,
+        checkedCount,
+        filteredOutEntries: filteredByTarget,
+        isDryRun,
+        store,
+        totalCatalogEntries: totalDeps
+      }),
+      {
+        alternateScreen: true,
+        exitOnCtrlC: false,
+        interactive: true,
+        patchConsole: true
+      }
+    );
+    const exitResult = await instance.waitUntilExit();
+    const columns = process.stdout.columns || 80;
+    process.stdout.write("\n");
+    for (const entry of outdated) {
+      const hasSecurityIssue = entry.vulnerabilities?.length || entry.socketReport && entry.socketReport.alerts.length > 0;
+      const isAck = Boolean(entry.acceptedRisk);
+      const icon = hasSecurityIssue ? isAck ? "✓" : "⚠" : "✓";
+      const iconColor = isAck ? "gray" : entry.updateType === "major" ? "red" : entry.updateType === "minor" ? "yellow" : "green";
+      const socketOverall = entry.socketReport?.score.overall;
+      const scoreSuffix = socketOverall === void 0 ? "" : ` [${String(Math.round(socketOverall * 100))}%]`;
+      const socketColorName = socketOverall === void 0 ? void 0 : scoreColor(socketOverall);
+      process.stdout.write(
+        `${renderToString(
+          React.createElement(
+            Text,
+            null,
+            "   ",
+            React.createElement(Text, { color: iconColor }, icon),
+            `  ${entry.packageName}  ${entry.currentRange} → ${entry.newRange}`,
+            React.createElement(Text, { dimColor: true }, `  ${entry.updateType}`),
+            socketColorName ? React.createElement(Text, { color: socketColorName }, scoreSuffix) : null
+          ),
+          { columns }
+        )}
+`
+      );
+    }
+    process.stdout.write("\n");
+    logger.info(formatSummary(outdated));
+    if (checkedCount > outdated.length) {
+      const totalCatalogEntries = [...catalogs.values()].reduce((sum, deps) => sum + deps.size, 0);
+      const dedupeNote = totalCatalogEntries > checkedCount ? ` (${String(totalCatalogEntries)} catalog entries, ${String(totalCatalogEntries - checkedCount)} duplicates)` : "";
+      logger.info(
+        `  Checked ${String(checkedCount)} unique packages${dedupeNote}: ${String(upToDate)} up-to-date${failed.length > 0 ? `, ${String(failed.length)} failed` : ""}`
+      );
+    }
+    if (filteredByTarget.length > 0) {
+      process.stdout.write("\n");
+      const skippedLabel = `${String(filteredByTarget.length)} package${filteredByTarget.length === 1 ? "" : "s"} skipped by target constraint (use --target latest to include):`;
+      process.stdout.write(`${renderToString(React.createElement(Text, { color: "yellow" }, `  ${skippedLabel}`), { columns })}
+`);
+      for (const entry of filteredByTarget) {
+        process.stdout.write(
+          `${renderToString(
+            React.createElement(
+              Text,
+              null,
+              "     ",
+              React.createElement(Text, { dimColor: true }, entry.packageName),
+              `  ${entry.currentRange} → ${entry.newRange}`,
+              React.createElement(Text, { dimColor: true }, `  ${entry.updateType}`)
+            ),
+            { columns }
+          )}
+`
+        );
+      }
+    }
+    const toApply2 = Array.isArray(exitResult) ? exitResult : [];
+    if (toApply2.length > 0 && !isDryRun) {
+      logger.info(`
+Applying ${String(toApply2.length)} updates...
+`);
+      const mergedOptions2 = { ...options, install: options.install ?? configDefaults.install };
+      await applyCatalogAndInstall(workspaceRoot, packageManager, toApply2, mergedOptions2, logger);
+    }
+    return;
+  }
+  if (isDryRun) {
+    if (format === "json") {
+      const output = { failed, filteredByTarget, ignored, outdated };
+      if (aiResult) {
+        output.aiAnalysis = aiResult;
+      }
+      process.stdout.write(`${JSON.stringify(output, void 0, 2)}
+`);
+    } else {
+      logger.info(`Would update ${String(outdated.length)} dependencies:
+`);
+      writeFormattedOutput(outdated, failed, format, logger);
+      if (aiResult) {
+        logger.info("");
+        logger.info(formatAiAnalysis(aiResult));
+      }
+      logFilteredByTarget(filteredByTarget, logger);
+    }
+    return;
+  }
+  if (aiResult && format !== "json") {
+    logger.info(formatAiAnalysis(aiResult));
+    logger.info("");
+  }
+  let toApply = outdated;
+  if (options.interactive) {
+    toApply = await promptPackageSelection(outdated);
+    if (toApply.length === 0) {
+      logger.info("No updates selected.");
+      return;
+    }
+  }
+  logger.info(`Updating ${String(toApply.length)} catalog dependencies...
+`);
+  writeFormattedOutput(toApply, [], format, logger);
+  logFilteredByTarget(filteredByTarget, logger);
+  const mergedOptions = { ...options, install: options.install ?? configDefaults.install };
+  await applyCatalogAndInstall(workspaceRoot, packageManager, toApply, mergedOptions, logger);
+};
+const executePmWrapper = (workspaceRoot, packageManager, version, options, argument, logger) => {
+  const updateOptions = {
+    dev: options.dev,
+    filters: toFilterArray(options.filter),
+    global: options.global,
+    interactive: options.interactive,
+    latest: options.latest || options.target === "latest",
+    noOptional: options.noOptional,
+    noSave: options.noSave,
+    packages: argument,
+    prod: options.prod,
+    recursive: options.recursive,
+    workspaceRoot: options.workspaceRoot
+  };
+  const { command, warnings } = resolveUpdateCommand(packageManager, version, updateOptions);
+  for (const warning of warnings) {
+    logger.warn(warning);
+  }
+  const fullCommand = `${command.bin} ${command.args.join(" ")}`.trim();
+  if (options.dryRun) {
+    logger.info(`Would run: ${fullCommand}`);
+    return;
+  }
+  logger.info(`Running: ${fullCommand}`);
+  try {
+    execSync(fullCommand, {
+      cwd: workspaceRoot,
+      env: process.env,
+      stdio: "inherit"
+    });
+  } catch (error) {
+    const execError = error;
+    const exitCode = execError.status ?? 1;
+    logger.error(`
+${red("✖")} Update failed (exit code ${String(exitCode)})`);
+    logger.error(`  Command: ${fullCommand}`);
+    logger.error(`  Directory: ${workspaceRoot}
+`);
+    process.exitCode = exitCode;
+  }
+};
+const execute = async ({ argument: rawArgument, logger, options, visConfig, workspaceRoot: wsRoot }) => {
+  if (!wsRoot) {
+    throw new Error("Could not determine workspace root. Run this command inside a monorepo.");
+  }
+  let argument = rawArgument;
+  const workspaceRoot = wsRoot;
+  const { packageManager } = findPackageManagerSync(workspaceRoot);
+  if (!options.noTyposquatCheck) {
+    if (argument.length > 0) {
+      const parsed = argument.map((a) => parsePackageArgument(a));
+      const allowlist = visConfig?.security?.typosquatAllowlist;
+      const result = await runTyposquatCheck(
+        parsed.map((p) => p.name),
+        allowlist
+      );
+      if (!result.ok) {
+        process.exitCode = 1;
+        return;
+      }
+      argument = parsed.map((p, i) => {
+        const corrected = result.packages[i];
+        if (corrected !== p.name) {
+          return p.versionSpec ? `${corrected}@${p.versionSpec}` : corrected ?? "";
+        }
+        return argument[i] ?? "";
+      });
+    } else {
+      const shouldContinue = await scanDepsForTyposquats(workspaceRoot, visConfig?.security?.typosquatAllowlist);
+      if (!shouldContinue) {
+        process.exitCode = 1;
+        return;
+      }
+    }
+  }
+  if (options.rollback) {
+    if (!hasBackup(workspaceRoot, packageManager)) {
+      logger.info("No backup found. Run 'vis update' first to create a backup.");
+      return;
+    }
+    const restored = restoreFromBackup(workspaceRoot, packageManager);
+    if (restored) {
+      logger.info("Restored from backup.");
+    } else {
+      throw new Error("Failed to restore from backup.");
+    }
+    return;
+  }
+  const useCatalogMode = !options.noCatalog && hasCatalogs(workspaceRoot, packageManager);
+  if (useCatalogMode) {
+    await executeCatalogUpdate(
+      workspaceRoot,
+      packageManager,
+      visConfig ?? {},
+      options,
+      argument,
+      logger
+    );
+  } else {
+    const installer = resolveInstaller(workspaceRoot, { configBackend: visConfig?.install?.backend });
+    const installerVersion = installer.name === "aube" ? "" : getPackageManagerVersion(installer.name);
+    executePmWrapper(workspaceRoot, installer.name, installerVersion, options, argument, logger);
+  }
+};
+
+export { execute as default };