@nuxt/cli-nightly 3.26.0-20250607-210256-59f83b1 → 3.26.0-20250607-215204-1943f84

package/dist/chunks/add2.mjs

@@ -1,335 +1,319 @@
-import * as fs from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { existsSync, promises } from 'node:fs';
 import process from 'node:process';
-import { updateConfig } from 'c12/update';
 import { defineCommand } from 'citty';
-import { colors } from 'consola/utils';
-import { addDependency } from 'nypm';
-import { $fetch } from 'ofetch';
-import { resolve } from 'pathe';
-import { readPackageJSON } from 'pkg-types';
-import { satisfies } from 'semver';
-import { joinURL } from 'ufo';
-import { r as runCommand } from '../shared/cli-nightly.DTVmTXKJ.mjs';
-import { l as logLevelArgs, c as cwdArgs, a as logger } from '../shared/cli-nightly.CjK7ZDKA.mjs';
-import { f as fetchModules, g as getNuxtVersion, c as checkNuxtCompatibility } from '../shared/cli-nightly.C935N1ss.mjs';
+import { resolve, extname, dirname } from 'pathe';
+import { l as loadKit } from '../shared/cli-nightly.BrKZotr9.mjs';
+import { l as logger } from '../shared/cli-nightly.B9AmABr3.mjs';
+import { pascalCase, camelCase } from 'scule';
+import { a as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.BgFMCBoq.mjs';
 import 'node:url';
-import 'node:crypto';
-import 'std-env';
-import '../shared/cli-nightly.DPQxxyDx.mjs';
+import 'exsolve';
 import 'consola';
+import 'node:path';
+import 'std-env';
+
+const httpMethods = [
+  "connect",
+  "delete",
+  "get",
+  "head",
+  "options",
+  "post",
+  "put",
+  "trace",
+  "patch"
+];
+const api = ({ name, args, nuxtOptions }) => {
+  return {
+    path: resolve(nuxtOptions.srcDir, nuxtOptions.serverDir, `api/${name}${applySuffix(args, httpMethods, "method")}.ts`),
+    contents: `
+export default defineEventHandler(event => {
+  return 'Hello ${name}'
+})
+`
+  };
+};
+
+const app = ({ args, nuxtOptions }) => ({
+  path: resolve(nuxtOptions.srcDir, "app.vue"),
+  contents: args.pages ? `
+<script setup lang="ts"><\/script>
+
+<template>
+  <div>
+    <NuxtLayout>
+      <NuxtPage/>
+    </NuxtLayout>
+  </div>
+</template>
+
+<style scoped></style>
+` : `
+<script setup lang="ts"><\/script>
+
+<template>
+  <div>
+    <h1>Hello World!</h1>
+  </div>
+</template>
+
+<style scoped></style>
+`
+});
+
+const appConfig = ({ nuxtOptions }) => ({
+  path: resolve(nuxtOptions.srcDir, "app.config.ts"),
+  contents: `
+export default defineAppConfig({})
+`
+});
+
+const component = ({ name, args, nuxtOptions }) => ({
+  path: resolve(nuxtOptions.srcDir, `components/${name}${applySuffix(
+    args,
+    ["client", "server"],
+    "mode"
+  )}.vue`),
+  contents: `
+<script setup lang="ts"><\/script>
+
+<template>
+  <div>
+    Component: ${name}
+  </div>
+</template>
+
+<style scoped></style>
+`
+});
+
+const composable = ({ name, nuxtOptions }) => {
+  const nameWithoutUsePrefix = name.replace(/^use-?/, "");
+  const nameWithUsePrefix = `use${pascalCase(nameWithoutUsePrefix)}`;
+  return {
+    path: resolve(nuxtOptions.srcDir, `composables/${name}.ts`),
+    contents: `
+export const ${nameWithUsePrefix} = () => {
+  return ref()
+}
+    `
+  };
+};
+
+const error = ({ nuxtOptions }) => ({
+  path: resolve(nuxtOptions.srcDir, "error.vue"),
+  contents: `
+<script setup lang="ts">
+import type { NuxtError } from '#app'
+
+const props = defineProps({
+  error: Object as () => NuxtError
+})
+<\/script>
+
+<template>
+  <div>
+    <h1>{{ error.statusCode }}</h1>
+    <NuxtLink to="/">Go back home</NuxtLink>
+  </div>
+</template>
+
+<style scoped></style>
+`
+});
+
+const layer = ({ name, nuxtOptions }) => {
+  return {
+    path: resolve(nuxtOptions.srcDir, `layers/${name}/nuxt.config.ts`),
+    contents: `
+export default defineNuxtConfig({})
+`
+  };
+};
+
+const layout = ({ name, nuxtOptions }) => ({
+  path: resolve(nuxtOptions.srcDir, nuxtOptions.dir.layouts, `${name}.vue`),
+  contents: `
+<script setup lang="ts"><\/script>
+
+<template>
+  <div>
+    Layout: ${name}
+    <slot />
+  </div>
+</template>
+
+<style scoped></style>
+`
+});
+
+const middleware = ({ name, args, nuxtOptions }) => ({
+  path: resolve(nuxtOptions.srcDir, nuxtOptions.dir.middleware, `${name}${applySuffix(args, ["global"])}.ts`),
+  contents: `
+export default defineNuxtRouteMiddleware((to, from) => {})
+`
+});
+
+const module = ({ name, nuxtOptions }) => ({
+  path: resolve(nuxtOptions.rootDir, "modules", `${name}.ts`),
+  contents: `
+import { defineNuxtModule } from 'nuxt/kit'
+
+export default defineNuxtModule({
+  meta: {
+    name: '${name}'
+  },
+  setup () {}
+})
+`
+});
+
+const page = ({ name, nuxtOptions }) => ({
+  path: resolve(nuxtOptions.srcDir, nuxtOptions.dir.pages, `${name}.vue`),
+  contents: `
+<script setup lang="ts"><\/script>
+
+<template>
+  <div>
+    Page: ${name}
+  </div>
+</template>
+
+<style scoped></style>
+`
+});
+
+const plugin = ({ name, args, nuxtOptions }) => ({
+  path: resolve(nuxtOptions.srcDir, nuxtOptions.dir.plugins, `${name}${applySuffix(args, ["client", "server"], "mode")}.ts`),
+  contents: `
+export default defineNuxtPlugin(nuxtApp => {})
+  `
+});
+
+const serverMiddleware = ({ name, nuxtOptions }) => ({
+  path: resolve(nuxtOptions.srcDir, nuxtOptions.serverDir, "middleware", `${name}.ts`),
+  contents: `
+export default defineEventHandler(event => {})
+`
+});
+
+const serverPlugin = ({ name, nuxtOptions }) => ({
+  path: resolve(nuxtOptions.srcDir, nuxtOptions.serverDir, "plugins", `${name}.ts`),
+  contents: `
+export default defineNitroPlugin(nitroApp => {})
+`
+});
+
+const serverRoute = ({ name, args, nuxtOptions }) => ({
+  path: resolve(nuxtOptions.srcDir, nuxtOptions.serverDir, args.api ? "api" : "routes", `${name}.ts`),
+  contents: `
+export default defineEventHandler(event => {})
+`
+});
+
+const serverUtil = ({ name, nuxtOptions }) => ({
+  path: resolve(nuxtOptions.srcDir, nuxtOptions.serverDir, "utils", `${name}.ts`),
+  contents: `
+export function ${camelCase(name)}() {}
+`
+});
 
+const templates = {
+  "api": api,
+  "app": app,
+  "app-config": appConfig,
+  "component": component,
+  "composable": composable,
+  "error": error,
+  "layer": layer,
+  "layout": layout,
+  "middleware": middleware,
+  "module": module,
+  "page": page,
+  "plugin": plugin,
+  "server-middleware": serverMiddleware,
+  "server-plugin": serverPlugin,
+  "server-route": serverRoute,
+  "server-util": serverUtil
+};
+function applySuffix(args, suffixes, unwrapFrom) {
+  let suffix = "";
+  for (const s of suffixes) {
+    if (args[s]) {
+      suffix += `.${s}`;
+    }
+  }
+  if (unwrapFrom && args[unwrapFrom] && suffixes.includes(args[unwrapFrom])) {
+    suffix += `.${args[unwrapFrom]}`;
+  }
+  return suffix;
+}
+
+const templateNames = Object.keys(templates);
 const add = defineCommand({
   meta: {
     name: "add",
-    description: "Add Nuxt modules"
+    description: "Create a new template file."
   },
   args: {
     ...cwdArgs,
     ...logLevelArgs,
-    moduleName: {
-      type: "positional",
-      description: "Specify one or more modules to install by name, separated by spaces"
-    },
-    skipInstall: {
+    force: {
       type: "boolean",
-      description: "Skip npm install"
+      description: "Force override file if it already exists",
+      default: false
     },
-    skipConfig: {
-      type: "boolean",
-      description: "Skip nuxt.config.ts update"
+    template: {
+      type: "positional",
+      required: true,
+      valueHint: templateNames.join("|"),
+      description: `Specify which template to generate`
     },
-    dev: {
-      type: "boolean",
-      description: "Install modules as dev dependencies"
+    name: {
+      type: "positional",
+      required: true,
+      description: "Specify name of the generated file"
     }
   },
-  async setup(ctx) {
+  async run(ctx) {
     const cwd = resolve(ctx.args.cwd);
-    const modules = ctx.args._.map((e) => e.trim()).filter(Boolean);
-    const projectPkg = await readPackageJSON(cwd).catch(() => ({}));
-    if (!projectPkg.dependencies?.nuxt && !projectPkg.devDependencies?.nuxt) {
-      logger.warn(`No \`nuxt\` dependency detected in \`${cwd}\`.`);
-      const shouldContinue = await logger.prompt(
-        `Do you want to continue anyway?`,
-        {
-          type: "confirm",
-          initial: false,
-          cancel: "default"
-        }
+    const templateName = ctx.args.template;
+    if (!templateNames.includes(templateName)) {
+      logger.error(
+        `Template ${templateName} is not supported. Possible values: ${Object.keys(
+          templates
+        ).join(", ")}`
       );
-      if (shouldContinue !== true) {
-        process.exit(1);
-      }
+      process.exit(1);
     }
-    const maybeResolvedModules = await Promise.all(modules.map((moduleName) => resolveModule(moduleName, cwd)));
-    const resolvedModules = maybeResolvedModules.filter((x) => x != null);
-    logger.info(`Resolved \`${resolvedModules.map((x) => x.pkgName).join("`, `")}\`, adding module${resolvedModules.length > 1 ? "s" : ""}...`);
-    await addModules(resolvedModules, { ...ctx.args, cwd }, projectPkg);
-    if (!ctx.args.skipInstall) {
-      const args = Object.entries(ctx.args).filter(([k]) => k in cwdArgs || k in logLevelArgs).map(([k, v]) => `--${k}=${v}`);
-      await runCommand("prepare", args);
+    const ext = extname(ctx.args.name);
+    const name = ext === ".vue" || ext === ".ts" ? ctx.args.name.replace(ext, "") : ctx.args.name;
+    if (!name) {
+      logger.error("name argument is missing!");
+      process.exit(1);
     }
-  }
-});
-async function addModules(modules, { skipInstall, skipConfig, cwd, dev }, projectPkg) {
-  if (!skipInstall) {
-    const installedModules = [];
-    const notInstalledModules = [];
-    const dependencies = /* @__PURE__ */ new Set([
-      ...Object.keys(projectPkg.dependencies || {}),
-      ...Object.keys(projectPkg.devDependencies || {})
-    ]);
-    for (const module of modules) {
-      if (dependencies.has(module.pkgName)) {
-        installedModules.push(module);
-      } else {
-        notInstalledModules.push(module);
-      }
-    }
-    if (installedModules.length > 0) {
-      const installedModulesList = installedModules.map((module) => module.pkgName).join("`, `");
-      const are = installedModules.length > 1 ? "are" : "is";
-      logger.info(`\`${installedModulesList}\` ${are} already installed`);
-    }
-    if (notInstalledModules.length > 0) {
-      const isDev = Boolean(projectPkg.devDependencies?.nuxt) || dev;
-      const notInstalledModulesList = notInstalledModules.map((module) => module.pkg).join("`, `");
-      const dependency = notInstalledModules.length > 1 ? "dependencies" : "dependency";
-      const a = notInstalledModules.length > 1 ? "" : " a";
-      logger.info(`Installing \`${notInstalledModulesList}\` as${a}${isDev ? " development" : ""} ${dependency}`);
-      const res = await addDependency(notInstalledModules.map((module) => module.pkg), {
-        cwd,
-        dev: isDev,
-        installPeerDependencies: true
-      }).then(() => true).catch(
-        (error) => {
-          logger.error(error);
-          const failedModulesList = notInstalledModules.map((module) => colors.cyan(module.pkg)).join("`, `");
-          const s = notInstalledModules.length > 1 ? "s" : "";
-          return logger.prompt(`Install failed for \`${failedModulesList}\`. Do you want to continue adding the module${s} to ${colors.cyan("nuxt.config")}?`, {
-            type: "confirm",
-            initial: false,
-            cancel: "default"
-          });
-        }
-      );
-      if (res !== true) {
-        return;
-      }
-    }
-  }
-  if (!skipConfig) {
-    await updateConfig({
-      cwd,
-      configFile: "nuxt.config",
-      async onCreate() {
-        logger.info(`Creating \`nuxt.config.ts\``);
-        return getDefaultNuxtConfig();
-      },
-      async onUpdate(config) {
-        if (!config.modules) {
-          config.modules = [];
-        }
-        for (const resolved of modules) {
-          if (config.modules.includes(resolved.pkgName)) {
-            logger.info(`\`${resolved.pkgName}\` is already in the \`modules\``);
-            continue;
-          }
-          logger.info(`Adding \`${resolved.pkgName}\` to the \`modules\``);
-          config.modules.push(resolved.pkgName);
-        }
-      }
-    }).catch((error) => {
-      logger.error(`Failed to update \`nuxt.config\`: ${error.message}`);
-      logger.error(`Please manually add \`${modules.map((module) => module.pkgName).join("`, `")}\` to the \`modules\` in \`nuxt.config.ts\``);
-      return null;
-    });
-  }
-}
-function getDefaultNuxtConfig() {
-  return `
-// https://nuxt.com/docs/api/configuration/nuxt-config
-export default defineNuxtConfig({
-  modules: []
-})`;
-}
-const packageRegex = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?([a-z0-9-~][a-z0-9-._~]*)(@[^@]+)?$/;
-async function resolveModule(moduleName, cwd) {
-  let pkgName = moduleName;
-  let pkgVersion;
-  const reMatch = moduleName.match(packageRegex);
-  if (reMatch) {
-    if (reMatch[3]) {
-      pkgName = `${reMatch[1] || ""}${reMatch[2] || ""}`;
-      pkgVersion = reMatch[3].slice(1);
-    }
-  } else {
-    logger.error(`Invalid package name \`${pkgName}\`.`);
-    return false;
-  }
-  const modulesDB = await fetchModules().catch((err) => {
-    logger.warn(`Cannot search in the Nuxt Modules database: ${err}`);
-    return [];
-  });
-  const matchedModule = modulesDB.find(
-    (module) => module.name === moduleName || pkgVersion && module.name === pkgName || module.npm === pkgName || module.aliases?.includes(pkgName)
-  );
-  if (matchedModule?.npm) {
-    pkgName = matchedModule.npm;
-  }
-  if (matchedModule && matchedModule.compatibility.nuxt) {
-    const nuxtVersion = await getNuxtVersion(cwd);
-    if (!checkNuxtCompatibility(matchedModule, nuxtVersion)) {
-      logger.warn(
-        `The module \`${pkgName}\` is not compatible with Nuxt \`${nuxtVersion}\` (requires \`${matchedModule.compatibility.nuxt}\`)`
-      );
-      const shouldContinue = await logger.prompt(
-        "Do you want to continue installing incompatible version?",
-        {
-          type: "confirm",
-          initial: false,
-          cancel: "default"
-        }
+    const kit = await loadKit(cwd);
+    const config = await kit.loadNuxtConfig({ cwd });
+    const template = templates[templateName];
+    const res = template({ name, args: ctx.args, nuxtOptions: config });
+    if (!ctx.args.force && existsSync(res.path)) {
+      logger.error(
+        `File exists: ${res.path} . Use --force to override or use a different name.`
       );
-      if (!shouldContinue) {
-        return false;
-      }
+      process.exit(1);
     }
-    const versionMap = matchedModule.compatibility.versionMap;
-    if (versionMap) {
-      for (const [_nuxtVersion, _moduleVersion] of Object.entries(versionMap)) {
-        if (satisfies(nuxtVersion, _nuxtVersion)) {
-          if (!pkgVersion) {
-            pkgVersion = _moduleVersion;
-          } else {
-            logger.warn(
-              `Recommended version of \`${pkgName}\` for Nuxt \`${nuxtVersion}\` is \`${_moduleVersion}\` but you have requested \`${pkgVersion}\``
-            );
-            pkgVersion = await logger.prompt("Choose a version:", {
-              type: "select",
-              options: [_moduleVersion, pkgVersion],
-              cancel: "undefined"
-            });
-            if (!pkgVersion) {
-              return false;
-            }
-          }
-          break;
-        }
-      }
-    }
-  }
-  let version = pkgVersion || "latest";
-  const pkgScope = pkgName.startsWith("@") ? pkgName.split("/")[0] : null;
-  const meta = await detectNpmRegistry(pkgScope);
-  const headers = {};
-  if (meta.authToken) {
-    headers.Authorization = `Bearer ${meta.authToken}`;
-  }
-  const pkgDetails = await $fetch(joinURL(meta.registry, `${pkgName}`), { headers });
-  if (pkgDetails["dist-tags"]?.[version]) {
-    version = pkgDetails["dist-tags"][version];
-  } else {
-    version = Object.keys(pkgDetails.versions)?.findLast((v) => satisfies(v, version)) || version;
-  }
-  const pkg = pkgDetails.versions[version];
-  const pkgDependencies = Object.assign(
-    pkg.dependencies || {},
-    pkg.devDependencies || {}
-  );
-  if (!pkgDependencies.nuxt && !pkgDependencies["nuxt-edge"] && !pkgDependencies["@nuxt/kit"]) {
-    logger.warn(`It seems that \`${pkgName}\` is not a Nuxt module.`);
-    const shouldContinue = await logger.prompt(
-      `Do you want to continue installing ${colors.cyan(pkgName)} anyway?`,
-      {
-        type: "confirm",
-        initial: false,
-        cancel: "default"
+    const parentDir = dirname(res.path);
+    if (!existsSync(parentDir)) {
+      logger.info("Creating directory", parentDir);
+      if (templateName === "page") {
+        logger.info("This enables vue-router functionality!");
       }
-    );
-    if (!shouldContinue) {
-      return false;
+      await promises.mkdir(parentDir, { recursive: true });
     }
+    await promises.writeFile(res.path, `${res.contents.trim()}
+`);
+    logger.info(`\u{1FA84} Generated a new ${templateName} in ${res.path}`);
   }
-  return {
-    nuxtModule: matchedModule,
-    pkg: `${pkgName}@${version}`,
-    pkgName,
-    pkgVersion: version
-  };
-}
-function getNpmrcPaths() {
-  const userNpmrcPath = join(homedir(), ".npmrc");
-  const cwdNpmrcPath = join(process.cwd(), ".npmrc");
-  return [cwdNpmrcPath, userNpmrcPath];
-}
-async function getAuthToken(registry) {
-  const paths = getNpmrcPaths();
-  const authTokenRegex = new RegExp(`^//${registry.replace(/^https?:\/\//, "").replace(/\/$/, "")}/:_authToken=(.+)$`, "m");
-  for (const npmrcPath of paths) {
-    let fd;
-    try {
-      fd = await fs.promises.open(npmrcPath, "r");
-      if (await fd.stat().then((r) => r.isFile())) {
-        const npmrcContent = await fd.readFile("utf-8");
-        const authTokenMatch = npmrcContent.match(authTokenRegex)?.[1];
-        if (authTokenMatch) {
-          return authTokenMatch.trim();
-        }
-      }
-    } catch {
-    } finally {
-      await fd?.close();
-    }
-  }
-  return null;
-}
-async function detectNpmRegistry(scope) {
-  const registry = await getRegistry(scope);
-  const authToken = await getAuthToken(registry);
-  return {
-    registry,
-    authToken
-  };
-}
-async function getRegistry(scope) {
-  if (process.env.COREPACK_NPM_REGISTRY) {
-    return process.env.COREPACK_NPM_REGISTRY;
-  }
-  const registry = await getRegistryFromFile(getNpmrcPaths(), scope);
-  if (registry) {
-    process.env.COREPACK_NPM_REGISTRY = registry;
-  }
-  return registry || "https://registry.npmjs.org";
-}
-async function getRegistryFromFile(paths, scope) {
-  for (const npmrcPath of paths) {
-    let fd;
-    try {
-      fd = await fs.promises.open(npmrcPath, "r");
-      if (await fd.stat().then((r) => r.isFile())) {
-        const npmrcContent = await fd.readFile("utf-8");
-        if (scope) {
-          const scopedRegex = new RegExp(`^${scope}:registry=(.+)$`, "m");
-          const scopedMatch = npmrcContent.match(scopedRegex)?.[1];
-          if (scopedMatch) {
-            return scopedMatch.trim();
-          }
-        }
-        const defaultRegex = /^\s*registry=(.+)$/m;
-        const defaultMatch = npmrcContent.match(defaultRegex)?.[1];
-        if (defaultMatch) {
-          return defaultMatch.trim();
-        }
-      }
-    } catch {
-    } finally {
-      await fd?.close();
-    }
-  }
-  return null;
-}
+});
 
 export { add as default };

package/dist/chunks/analyze.mjs

@@ -5,15 +5,16 @@ import { defu } from 'defu';
 import { createApp, lazyEventHandler, eventHandler, toNodeListener } from 'h3';
 import { listen } from 'listhen';
 import { resolve, join } from 'pathe';
-import { o as overrideEnv } from '../shared/cli-nightly.DdmGgrsK.mjs';
-import { c as clearDir } from '../shared/cli-nightly.BnfAj4iy.mjs';
-import { l as loadKit } from '../shared/cli-nightly.DlcAx0De.mjs';
-import { d as dotEnvArgs, b as legacyRootDirArgs, l as logLevelArgs, c as cwdArgs, a as logger } from '../shared/cli-nightly.CjK7ZDKA.mjs';
-import 'jiti';
+import { o as overrideEnv } from '../shared/cli-nightly.DkO5RR_e.mjs';
+import { c as clearDir } from '../shared/cli-nightly.DPmMxQ6h.mjs';
+import { l as loadKit } from '../shared/cli-nightly.BrKZotr9.mjs';
+import { l as logger } from '../shared/cli-nightly.B9AmABr3.mjs';
+import { d as dotEnvArgs, l as legacyRootDirArgs, a as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.BgFMCBoq.mjs';
+import 'node:url';
+import 'exsolve';
+import 'consola';
 import 'node:path';
 import 'std-env';
-import 'consola';
-import 'node:url';
 
 const analyze = defineCommand({
   meta: {

package/dist/chunks/build.mjs

@@ -1,19 +1,19 @@
 import process from 'node:process';
 import { defineCommand } from 'citty';
 import { resolve, relative } from 'pathe';
-import { s as showVersions } from '../shared/cli-nightly.COGWopdX.mjs';
-import { o as overrideEnv } from '../shared/cli-nightly.DdmGgrsK.mjs';
-import { a as clearBuildDir } from '../shared/cli-nightly.BnfAj4iy.mjs';
-import { l as loadKit } from '../shared/cli-nightly.DlcAx0De.mjs';
-import { b as legacyRootDirArgs, e as envNameArgs, d as dotEnvArgs, l as logLevelArgs, c as cwdArgs, a as logger } from '../shared/cli-nightly.CjK7ZDKA.mjs';
-import 'consola/utils';
-import 'pkg-types';
+import { s as showVersions } from '../shared/cli-nightly.Dc8ncNQ_.mjs';
+import { o as overrideEnv } from '../shared/cli-nightly.DkO5RR_e.mjs';
+import { a as clearBuildDir } from '../shared/cli-nightly.DPmMxQ6h.mjs';
+import { l as loadKit } from '../shared/cli-nightly.BrKZotr9.mjs';
+import { l as logger } from '../shared/cli-nightly.B9AmABr3.mjs';
+import { l as legacyRootDirArgs, e as envNameArgs, d as dotEnvArgs, a as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.BgFMCBoq.mjs';
 import 'node:fs';
-import 'jiti';
+import 'consola/utils';
+import 'exsolve';
+import 'node:url';
+import 'consola';
 import 'node:path';
 import 'std-env';
-import 'consola';
-import 'node:url';
 
 const buildCommand = defineCommand({
   meta: {
@@ -38,7 +38,7 @@ const buildCommand = defineCommand({
   async run(ctx) {
     overrideEnv("production");
     const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
-    await showVersions(cwd);
+    showVersions(cwd);
     const kit = await loadKit(cwd);
     const nuxt = await kit.loadNuxt({
       cwd,