wxt 0.14.4 → 0.14.6

package/dist/cli.js

@@ -5,7 +5,7 @@ import "./chunk-73I7FAJU.js";
 import cac from "cac";
 
 // package.json
-var version = "0.14.4";
+var version = "0.14.6";
 
 // src/core/utils/fs.ts
 import fs from "fs-extra";
@@ -77,11 +77,27 @@ function every(array, predicate) {
       return false;
   return true;
 }
+function some(array, predicate) {
+  for (let i = 0; i < array.length; i++)
+    if (predicate(array[i], i))
+      return true;
+  return false;
+}
 
 // src/core/utils/building/detect-dev-changes.ts
-function detectDevChanges(changedFiles, currentOutput) {
-  if (currentOutput == null)
-    return { type: "no-change" };
+function detectDevChanges(config, changedFiles, currentOutput) {
+  const isConfigChange = some(
+    changedFiles,
+    (file) => file === config.userConfigMetadata.configFile
+  );
+  if (isConfigChange)
+    return { type: "full-restart" };
+  const isRunnerChange = some(
+    changedFiles,
+    (file) => file === config.runnerConfig.configFile
+  );
+  if (isRunnerChange)
+    return { type: "browser-restart" };
   const changedSteps = new Set(
     changedFiles.flatMap(
       (changedFile) => findEffectedSteps(changedFile, currentOutput)
@@ -113,7 +129,7 @@ function detectDevChanges(changedFiles, currentOutput) {
       unchangedOutput.publicAssets.push(asset);
     }
   }
-  const isOnlyHtmlChanges = changedFiles.length > 0 && every(changedFiles, ([_, file]) => file.endsWith(".html"));
+  const isOnlyHtmlChanges = changedFiles.length > 0 && every(changedFiles, (file) => file.endsWith(".html"));
   if (isOnlyHtmlChanges) {
     return {
       type: "html-reload",
@@ -141,7 +157,7 @@ function detectDevChanges(changedFiles, currentOutput) {
 }
 function findEffectedSteps(changedFile, currentOutput) {
   const changes = [];
-  const changedPath = normalizePath(changedFile[1]);
+  const changedPath = normalizePath(changedFile);
   const isChunkEffected = (chunk) => (
     // If it's an HTML file with the same path, is is effected because HTML files need to be pre-rendered
     // fileName is normalized, relative bundle path
@@ -1489,6 +1505,9 @@ async function createViteBuilder(inlineConfig, userConfig, wxtConfig) {
         async listen() {
           await viteServer.listen(info.port);
         },
+        async close() {
+          await viteServer.close();
+        },
         transformHtml(...args) {
           return viteServer.transformIndexHtml(...args);
         },
@@ -1554,6 +1573,7 @@ async function getInternalConfig(inlineConfig, command, server) {
   const typesDir = path3.resolve(wxtDir, "types");
   const outBaseDir = path3.resolve(root, mergedConfig.outDir ?? ".output");
   const outDir = path3.resolve(outBaseDir, `${browser}-mv${manifestVersion}`);
+  const reloadCommand = mergedConfig.dev?.reloadCommand ?? "Alt+R";
   const runnerConfig = await loadConfig({
     name: "web-ext",
     cwd: root,
@@ -1606,7 +1626,10 @@ async function getInternalConfig(inlineConfig, command, server) {
     experimental: {
       includeBrowserPolyfill: mergedConfig.experimental?.includeBrowserPolyfill ?? true
     },
-    server
+    server,
+    dev: {
+      reloadCommand
+    }
   };
   const builder = await createViteBuilder(
     inlineConfig,
@@ -1673,7 +1696,11 @@ function mergeInlineConfig(inlineConfig, userConfig) {
       ...inlineConfig.experimental
     },
     vite: void 0,
-    transformManifest: void 0
+    transformManifest: void 0,
+    dev: {
+      ...userConfig.dev,
+      ...inlineConfig.dev
+    }
   };
 }
 function resolveInternalZipConfig(root, mergedConfig) {
@@ -2089,6 +2116,7 @@ async function writeManifest(manifest, output, config) {
   });
 }
 async function generateManifest(entrypoints, buildOutput, config) {
+  const warnings = [];
   const pkg = await getPackageJson(config);
   let versionName = config.manifest.version_name ?? config.manifest.version ?? pkg?.version;
   if (versionName == null) {
@@ -2106,21 +2134,26 @@ async function generateManifest(entrypoints, buildOutput, config) {
     short_name: pkg?.shortName,
     icons: discoverIcons(buildOutput)
   };
-  if (config.command === "serve") {
-    baseManifest.commands = {
-      "wxt:reload-extension": {
-        description: "Reload the extension during development",
-        suggested_key: {
-          default: "Alt+R"
-        }
-      }
-    };
-  }
   const userManifest = config.manifest;
   const manifest = defu3(
     userManifest,
     baseManifest
   );
+  if (config.command === "serve" && config.dev.reloadCommand) {
+    if (manifest.commands && Object.keys(manifest.commands).length >= 4) {
+      warnings.push([
+        "Extension already has 4 registered commands, WXT's reload command is disabled"
+      ]);
+    } else {
+      manifest.commands ??= {};
+      manifest.commands["wxt:reload-extension"] = {
+        description: "Reload the extension during development",
+        suggested_key: {
+          default: config.dev.reloadCommand
+        }
+      };
+    }
+  }
   manifest.version = version2;
   manifest.version_name = // Firefox doesn't support version_name
   config.browser === "firefox" || versionName === version2 ? void 0 : versionName;
@@ -2139,7 +2172,10 @@ async function generateManifest(entrypoints, buildOutput, config) {
       "Manifest 'version' is missing. Either:\n1. Add a version in your <rootDir>/package.json\n2. Pass the version via the manifest option in your wxt.config.ts"
     );
   }
-  return finalManifest;
+  return {
+    manifest: finalManifest,
+    warnings
+  };
 }
 function simplifyVersion(versionName) {
   const version2 = /^((0|[1-9][0-9]{0,8})([.](0|[1-9][0-9]{0,8})){0,3}).*$/.exec(
@@ -2500,11 +2536,7 @@ async function rebuild(config, allEntrypoints, entrypointGroups, existingOutput
     steps: [...existingOutput.steps, ...newOutput.steps],
     publicAssets: [...existingOutput.publicAssets, ...newOutput.publicAssets]
   };
-  const newManifest = await generateManifest(
-    allEntrypoints,
-    mergedOutput,
-    config
-  );
+  const { manifest: newManifest, warnings: manifestWarnings } = await generateManifest(allEntrypoints, mergedOutput, config);
   const finalOutput = {
     manifest: newManifest,
     ...newOutput
@@ -2520,11 +2552,76 @@ async function rebuild(config, allEntrypoints, entrypointGroups, existingOutput
         ...finalOutput.publicAssets
       ]
     },
-    manifest: newManifest
+    manifest: newManifest,
+    warnings: manifestWarnings
   };
 }
 
 // src/core/utils/building/internal-build.ts
+import managePath from "manage-path";
+import { resolve as resolve13, relative as relative6 } from "node:path";
+
+// src/core/utils/validation.ts
+function validateEntrypoints(entrypoints) {
+  const errors = entrypoints.flatMap((entrypoint) => {
+    switch (entrypoint.type) {
+      case "content-script":
+        return validateContentScriptEntrypoint(entrypoint);
+      default:
+        return validateBaseEntrypoint(entrypoint);
+    }
+  });
+  let errorCount = 0;
+  let warningCount = 0;
+  for (const err of errors) {
+    if (err.type === "warning")
+      warningCount++;
+    else
+      errorCount++;
+  }
+  return {
+    errors,
+    errorCount,
+    warningCount
+  };
+}
+function validateContentScriptEntrypoint(definition) {
+  const errors = validateBaseEntrypoint(definition);
+  if (definition.options.matches == null) {
+    errors.push({
+      type: "error",
+      message: "`matches` is required",
+      value: definition.options.matches,
+      entrypoint: definition
+    });
+  }
+  return errors;
+}
+function validateBaseEntrypoint(definition) {
+  const errors = [];
+  if (definition.options.exclude != null && !Array.isArray(definition.options.exclude)) {
+    errors.push({
+      type: "error",
+      message: "`exclude` must be an array of browser names",
+      value: definition.options.exclude,
+      entrypoint: definition
+    });
+  }
+  if (definition.options.include != null && !Array.isArray(definition.options.include)) {
+    errors.push({
+      type: "error",
+      message: "`include` must be an array of browser names",
+      value: definition.options.include,
+      entrypoint: definition
+    });
+  }
+  return errors;
+}
+var ValidationError = class extends Error {
+};
+
+// src/core/utils/building/internal-build.ts
+import consola3 from "consola";
 async function internalBuild(config) {
   const verb = config.command === "serve" ? "Pre-rendering" : "Building";
   const target = `${config.browser}-mv${config.manifestVersion}`;
@@ -2538,14 +2635,31 @@ async function internalBuild(config) {
   await fs12.ensureDir(config.outDir);
   const entrypoints = await findEntrypoints(config);
   config.logger.debug("Detected entrypoints:", entrypoints);
+  const validationResults = validateEntrypoints(entrypoints);
+  if (validationResults.errorCount + validationResults.warningCount > 0) {
+    printValidationResults(config, validationResults);
+  }
+  if (validationResults.errorCount > 0) {
+    throw new ValidationError(`Entrypoint validation failed`, {
+      cause: validationResults
+    });
+  }
   const groups = groupEntrypoints(entrypoints);
-  const { output } = await rebuild(config, entrypoints, groups, void 0);
+  const { output, warnings } = await rebuild(
+    config,
+    entrypoints,
+    groups,
+    void 0
+  );
   await printBuildSummary(
     config.logger.success,
     `Built extension in ${formatDuration(Date.now() - startTime)}`,
     output,
     config
   );
+  for (const warning of warnings) {
+    config.logger.warn(...warning);
+  }
   if (config.analysis.enabled) {
     await combineAnalysisStats(config);
     config.logger.info(
@@ -2562,11 +2676,35 @@ async function combineAnalysisStats(config) {
     absolute: true
   });
   const absolutePaths = unixFiles.map(unnormalizePath);
+  const alterPath = managePath(process.env);
+  alterPath.push(resolve13(config.root, "node_modules/wxt/node_modules/.bin"));
   await execaCommand(
     `rollup-plugin-visualizer ${absolutePaths.join(" ")} --template ${config.analysis.template}`,
     { cwd: config.root, stdio: "inherit" }
   );
 }
+function printValidationResults(config, { errorCount, errors, warningCount }) {
+  (errorCount > 0 ? config.logger.error : config.logger.warn)(
+    `Entrypoint validation failed: ${errorCount} error${errorCount === 1 ? "" : "s"}, ${warningCount} warning${warningCount === 1 ? "" : "s"}`
+  );
+  const cwd = process.cwd();
+  const entrypointErrors = errors.reduce((map, error) => {
+    const entryErrors = map.get(error.entrypoint) ?? [];
+    entryErrors.push(error);
+    map.set(error.entrypoint, entryErrors);
+    return map;
+  }, /* @__PURE__ */ new Map());
+  Array.from(entrypointErrors.entries()).forEach(([entrypoint, errors2]) => {
+    consola3.log(relative6(cwd, entrypoint.inputPath));
+    console.log();
+    errors2.forEach((err) => {
+      const type = err.type === "error" ? pc5.red("ERROR") : pc5.yellow("WARN");
+      const recieved = pc5.dim(`(recieved: ${JSON.stringify(err.value)})`);
+      consola3.log(`  - ${type} ${err.message} ${recieved}`);
+    });
+    console.log();
+  });
+}
 
 // src/core/build.ts
 async function build(config) {
@@ -2578,17 +2716,17 @@ async function build(config) {
 import path5 from "node:path";
 import glob4 from "fast-glob";
 import fs13 from "fs-extra";
-import { consola as consola3 } from "consola";
+import { consola as consola4 } from "consola";
 import pc6 from "picocolors";
 async function clean(root = process.cwd()) {
-  consola3.info("Cleaning Project");
+  consola4.info("Cleaning Project");
   const tempDirs = [
     "node_modules/.vite",
     "node_modules/.cache",
     "**/.wxt",
     ".output/*"
   ];
-  consola3.debug("Looking for:", tempDirs.map(pc6.cyan).join(", "));
+  consola4.debug("Looking for:", tempDirs.map(pc6.cyan).join(", "));
   const directories = await glob4(tempDirs, {
     cwd: path5.resolve(root),
     absolute: true,
@@ -2596,26 +2734,26 @@ async function clean(root = process.cwd()) {
     deep: 2
   });
   if (directories.length === 0) {
-    consola3.debug("No generated files found.");
+    consola4.debug("No generated files found.");
     return;
   }
-  consola3.debug(
+  consola4.debug(
     "Found:",
     directories.map((dir) => pc6.cyan(path5.relative(root, dir))).join(", ")
   );
   for (const directory of directories) {
     await fs13.rm(directory, { force: true, recursive: true });
-    consola3.debug("Deleted " + pc6.cyan(path5.relative(root, directory)));
+    consola4.debug("Deleted " + pc6.cyan(path5.relative(root, directory)));
   }
 }
 
 // src/core/runners/wsl.ts
-import { relative as relative6 } from "node:path";
+import { relative as relative7 } from "node:path";
 function createWslRunner() {
   return {
     async openBrowser(config) {
       config.logger.warn(
-        `Cannot open browser when using WSL. Load "${relative6(
+        `Cannot open browser when using WSL. Load "${relative7(
           process.cwd(),
           config.outDir
         )}" as an unpacked extension manually`
@@ -2631,7 +2769,7 @@ function createWebExtRunner() {
   let runner;
   return {
     async openBrowser(config) {
-      config.logger.info("Opening browser...");
+      const startTime = Date.now();
       if (config.browser === "firefox" && config.manifestVersion === 3) {
         throw Error(
           "Dev mode does not support Firefox MV3. For alternatives, see https://github.com/wxt-dev/wxt/issues/230#issuecomment-1806881653"
@@ -2676,7 +2814,8 @@ function createWebExtRunner() {
       config.logger.debug("web-ext options:", options);
       const webExt = await import("web-ext-run");
       runner = await webExt.default.cmd.run(finalConfig, options);
-      config.logger.success("Opened!");
+      const duration = Date.now() - startTime;
+      config.logger.success(`Opened browser in ${formatDuration(duration)}`);
     },
     async closeBrowser() {
       return await runner?.exit();
@@ -2687,12 +2826,12 @@ var WARN_LOG_LEVEL = 40;
 var ERROR_LOG_LEVEL = 50;
 
 // src/core/runners/safari.ts
-import { relative as relative7 } from "node:path";
+import { relative as relative8 } from "node:path";
 function createSafariRunner() {
   return {
     async openBrowser(config) {
       config.logger.warn(
-        `Cannot Safari using web-ext. Load "${relative7(
+        `Cannot Safari using web-ext. Load "${relative8(
           process.cwd(),
           config.outDir
         )}" as an unpacked extension manually`
@@ -2704,12 +2843,12 @@ function createSafariRunner() {
 }
 
 // src/core/runners/manual.ts
-import { relative as relative8 } from "node:path";
+import { relative as relative9 } from "node:path";
 function createManualRunner() {
   return {
     async openBrowser(config) {
       config.logger.info(
-        `Load "${relative8(
+        `Load "${relative9(
           process.cwd(),
           config.outDir
         )}" as an unpacked extension manually`
@@ -2738,10 +2877,10 @@ async function createExtensionRunner(config) {
 }
 
 // src/core/create-server.ts
-import { consola as consola4 } from "consola";
+import { consola as consola5 } from "consola";
 import { Mutex } from "async-mutex";
 import pc7 from "picocolors";
-import { relative as relative9 } from "node:path";
+import { relative as relative10 } from "node:path";
 async function createServer(inlineConfig) {
   const port = await getPort();
   const hostname = "localhost";
@@ -2751,19 +2890,36 @@ async function createServer(inlineConfig) {
     hostname,
     origin
   };
+  const buildAndOpenBrowser = async () => {
+    server.currentOutput = await internalBuild(config);
+    await runner.openBrowser(config);
+  };
+  const closeAndRecreateRunner = async () => {
+    await runner.closeBrowser();
+    config = await getLatestConfig();
+    runner = await createExtensionRunner(config);
+  };
   const server = {
     ...serverInfo,
-    watcher: void 0,
-    // Filled out later down below
-    ws: void 0,
-    // Filled out later down below
+    get watcher() {
+      return builderServer.watcher;
+    },
+    get ws() {
+      return builderServer.ws;
+    },
     currentOutput: void 0,
-    // Filled out later down below
     async start() {
       await builderServer.listen();
       config.logger.success(`Started dev server @ ${serverInfo.origin}`);
-      server.currentOutput = await internalBuild(config);
-      await runner.openBrowser(config);
+      await buildAndOpenBrowser();
+    },
+    async stop() {
+      await runner.closeBrowser();
+      await builderServer.close();
+    },
+    async restart() {
+      await closeAndRecreateRunner();
+      await buildAndOpenBrowser();
     },
     transformHtml(url, html, originalUrl) {
       return builderServer.transformHtml(url, html, originalUrl);
@@ -2776,17 +2932,21 @@ async function createServer(inlineConfig) {
     },
     reloadExtension() {
       server.ws.send("wxt:reload-extension");
+    },
+    async restartBrowser() {
+      await closeAndRecreateRunner();
+      await runner.openBrowser(config);
     }
   };
   const getLatestConfig = () => getInternalConfig(inlineConfig ?? {}, "serve", server);
   let config = await getLatestConfig();
-  const [runner, builderServer] = await Promise.all([
+  let [runner, builderServer] = await Promise.all([
     createExtensionRunner(config),
     config.builder.createServer(server)
   ]);
-  server.watcher = builderServer.watcher;
-  server.ws = builderServer.ws;
   server.ws.on("wxt:background-initialized", () => {
+    if (server.currentOutput == null)
+      return;
     reloadContentScripts(server.currentOutput.steps, config, server);
   });
   const reloadOnChange = createFileReloader({
@@ -2814,18 +2974,34 @@ function createFileReloader(options) {
       return;
     changeQueue.push([event, path7]);
     await fileChangedMutex.runExclusive(async () => {
-      const fileChanges = changeQueue.splice(0, changeQueue.length);
+      if (server.currentOutput == null)
+        return;
+      const fileChanges = changeQueue.splice(0, changeQueue.length).map(([_, file]) => file);
       if (fileChanges.length === 0)
         return;
-      const changes = detectDevChanges(fileChanges, server.currentOutput);
+      const changes = detectDevChanges(
+        config,
+        fileChanges,
+        server.currentOutput
+      );
       if (changes.type === "no-change")
         return;
+      if (changes.type === "full-restart") {
+        config.logger.info("Config changed, restarting server...");
+        server.restart();
+        return;
+      }
+      if (changes.type === "browser-restart") {
+        config.logger.info("Runner config changed, restarting browser...");
+        server.restartBrowser();
+        return;
+      }
       config.logger.info(
-        `Changed: ${Array.from(new Set(fileChanges.map((change) => change[1]))).map((file) => pc7.dim(relative9(config.root, file))).join(", ")}`
+        `Changed: ${Array.from(new Set(fileChanges)).map((file) => pc7.dim(relative10(config.root, file))).join(", ")}`
       );
       const rebuiltNames = changes.rebuildGroups.flat().map((entry) => {
         return pc7.cyan(
-          relative9(config.outDir, getEntrypointOutputFile(entry, ""))
+          relative10(config.outDir, getEntrypointOutputFile(entry, ""))
         );
       }).join(pc7.dim(", "));
       const allEntrypoints = await findEntrypoints(config);
@@ -2848,13 +3024,15 @@ function createFileReloader(options) {
           reloadContentScripts(changes.changedSteps, config, server);
           break;
       }
-      consola4.success(`Reloaded: ${rebuiltNames}`);
+      consola5.success(`Reloaded: ${rebuiltNames}`);
     });
   };
 }
 function reloadContentScripts(steps, config, server) {
   if (config.manifestVersion === 3) {
     steps.forEach((step) => {
+      if (server.currentOutput == null)
+        return;
       const entry = step.entrypoints;
       if (Array.isArray(entry) || entry.type !== "content-script")
         return;
@@ -2891,13 +3069,13 @@ function reloadHtmlPages(groups, server, config) {
 
 // src/core/initialize.ts
 import prompts from "prompts";
-import { consola as consola5 } from "consola";
+import { consola as consola6 } from "consola";
 import { downloadTemplate } from "giget";
 import fs14 from "fs-extra";
 import path6 from "node:path";
 import pc8 from "picocolors";
 async function initialize(options) {
-  consola5.info("Initalizing new project");
+  consola6.info("Initalizing new project");
   const templates = await listTemplates();
   const defaultTemplate = templates.find(
     (template) => template.name === options.template?.toLowerCase().trim()
@@ -2944,15 +3122,15 @@ async function initialize(options) {
   await cloneProject(input);
   const cdPath = path6.relative(process.cwd(), path6.resolve(input.directory));
   console.log();
-  consola5.log(
+  consola6.log(
     `\u2728 WXT project created with the ${TEMPLATE_COLORS[input.template.name]?.(input.template.name) ?? input.template.name} template.`
   );
   console.log();
-  consola5.log("Next steps:");
+  consola6.log("Next steps:");
   let step = 0;
   if (cdPath !== "")
-    consola5.log(`  ${++step}.`, pc8.cyan(`cd ${cdPath}`));
-  consola5.log(`  ${++step}.`, pc8.cyan(`${input.packageManager} install`));
+    consola6.log(`  ${++step}.`, pc8.cyan(`cd ${cdPath}`));
+  consola6.log(`  ${++step}.`, pc8.cyan(`${input.packageManager} install`));
   console.log();
 }
 async function listTemplates() {
@@ -2997,7 +3175,7 @@ async function cloneProject({
       path6.join(directory, "_gitignore"),
       path6.join(directory, ".gitignore")
     ).catch(
-      (err) => consola5.warn("Failed to move _gitignore to .gitignore:", err)
+      (err) => consola6.warn("Failed to move _gitignore to .gitignore:", err)
     );
     spinner.succeed();
   } catch (err) {
@@ -3028,7 +3206,7 @@ async function prepare(config) {
 
 // src/core/zip.ts
 import zipdir from "zip-dir";
-import { dirname as dirname5, relative as relative10, resolve as resolve13 } from "node:path";
+import { dirname as dirname5, relative as relative11, resolve as resolve14 } from "node:path";
 import fs15 from "fs-extra";
 import { minimatch as minimatch2 } from "minimatch";
 async function zip(config) {
@@ -3046,7 +3224,7 @@ async function zip(config) {
   ).replaceAll("{{manifestVersion}}", `mv${internalConfig.manifestVersion}`);
   await fs15.ensureDir(internalConfig.outBaseDir);
   const outZipFilename = applyTemplate(internalConfig.zip.artifactTemplate);
-  const outZipPath = resolve13(internalConfig.outBaseDir, outZipFilename);
+  const outZipPath = resolve14(internalConfig.outBaseDir, outZipFilename);
   await zipdir(internalConfig.outDir, {
     saveTo: outZipPath
   });
@@ -3055,14 +3233,14 @@ async function zip(config) {
     const sourcesZipFilename = applyTemplate(
       internalConfig.zip.sourcesTemplate
     );
-    const sourcesZipPath = resolve13(
+    const sourcesZipPath = resolve14(
       internalConfig.outBaseDir,
       sourcesZipFilename
     );
     await zipdir(internalConfig.zip.sourcesRoot, {
       saveTo: sourcesZipPath,
       filter(path7) {
-        const relativePath = relative10(internalConfig.zip.sourcesRoot, path7);
+        const relativePath = relative11(internalConfig.zip.sourcesRoot, path7);
         const matchedPattern = internalConfig.zip.ignoredSources.find(
           (pattern) => minimatch2(relativePath, pattern)
         );
@@ -3081,7 +3259,7 @@ async function zip(config) {
 }
 
 // src/cli.ts
-import consola6, { LogLevels as LogLevels2 } from "consola";
+import consola7, { LogLevels as LogLevels2 } from "consola";
 process.env.VITE_CJS_IGNORE_WARNING = "true";
 var cli = cac("wxt");
 cli.help();
@@ -3171,21 +3349,24 @@ function wrapAction(cb, options) {
   return async (...args) => {
     const isDebug = !!args.find((arg) => arg?.debug);
     if (isDebug) {
-      consola6.level = LogLevels2.debug;
+      consola7.level = LogLevels2.debug;
     }
     const startTime = Date.now();
     try {
       printHeader();
       const status = await cb(...args);
       if (!status?.isOngoing && !options?.disableFinishedLog)
-        consola6.success(
+        consola7.success(
           `Finished in ${formatDuration(Date.now() - startTime)}`
         );
     } catch (err) {
-      consola6.fail(
+      consola7.fail(
         `Command failed after ${formatDuration(Date.now() - startTime)}`
       );
-      consola6.error(err);
+      if (err instanceof ValidationError) {
+      } else {
+        consola7.error(err);
+      }
       process.exit(1);
     }
   };