create-better-t-stack 3.10.0 → 3.11.0-pr749.0

package/src/constants.ts

@@ -0,0 +1,270 @@
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import { getUserPkgManager } from "./utils/get-package-manager";
+
+/**
+ * Detect if running as a compiled Bun binary.
+ * Compiled binaries have Bun.main pointing to the executable itself,
+ * not a .ts or .js file.
+ */
+function isCompiledBinary(): boolean {
+  if (typeof Bun === "undefined") return false;
+  const main = Bun.main;
+  // Compiled binaries don't have .ts, .js, or .mjs extensions
+  return !main.endsWith(".ts") && !main.endsWith(".js") && !main.endsWith(".mjs");
+}
+
+/**
+ * Find the main create-better-t-stack package in node_modules.
+ * Used when running as a compiled binary from a platform package.
+ */
+function findMainPackage(): string | null {
+  // Use process.execPath to get actual filesystem path (Bun.main returns bunfs virtual path)
+  let current = path.dirname(process.execPath);
+
+  // Search up the directory tree for node_modules/create-better-t-stack
+  while (current !== path.dirname(current)) {
+    const candidate = path.join(current, "node_modules", "create-better-t-stack");
+    const templatesPath = path.join(candidate, "templates");
+
+    if (fs.existsSync(templatesPath)) {
+      return candidate;
+    }
+
+    current = path.dirname(current);
+  }
+
+  return null;
+}
+
+/**
+ * Get the package root directory.
+ * - In JS mode (development/tsdown build): relative to dist/
+ * - In compiled binary mode: find main package in node_modules, or use dev fallback
+ */
+function getPkgRoot(): string {
+  if (isCompiledBinary()) {
+    // First try: find main package in node_modules (production npm install)
+    const mainPkg = findMainPackage();
+    if (mainPkg) {
+      return mainPkg;
+    }
+
+    // Second try: development mode - binary is in dist/create-better-t-stack-{platform}-{arch}/bin/
+    // Use process.execPath to get actual filesystem path (Bun.main returns bunfs virtual path)
+    const binaryPath = process.execPath;
+    const binaryDir = path.dirname(binaryPath);
+
+    // Templates are at ../../../templates relative to the binary (bin -> platform-dir -> dist -> apps/cli)
+    const devTemplatesPath = path.resolve(binaryDir, "..", "..", "..", "templates");
+    if (fs.existsSync(devTemplatesPath)) {
+      return path.resolve(binaryDir, "..", "..", "..");
+    }
+
+    // Third try: templates might be at ../../templates (if binary is in dist/bin/)
+    const altTemplatesPath = path.resolve(binaryDir, "..", "..", "templates");
+    if (fs.existsSync(altTemplatesPath)) {
+      return path.resolve(binaryDir, "..", "..");
+    }
+
+    // Fourth try: templates at ../templates
+    const simpleTemplatesPath = path.resolve(binaryDir, "..", "templates");
+    if (fs.existsSync(simpleTemplatesPath)) {
+      return path.resolve(binaryDir, "..");
+    }
+  }
+
+  // Standard JS mode - relative to this file in dist/
+  const __filename = fileURLToPath(import.meta.url);
+  const distPath = path.dirname(__filename);
+  return path.join(distPath, "../");
+}
+
+export const PKG_ROOT = getPkgRoot();
+
+export const DEFAULT_CONFIG_BASE = {
+  projectName: "my-better-t-app",
+  relativePath: "my-better-t-app",
+  frontend: ["tanstack-router"],
+  database: "sqlite",
+  orm: "drizzle",
+  auth: "better-auth",
+  payments: "none",
+  addons: ["turborepo"],
+  examples: [],
+  git: true,
+  install: true,
+  dbSetup: "none",
+  backend: "hono",
+  runtime: "bun",
+  api: "trpc",
+  webDeploy: "none",
+  serverDeploy: "none",
+} as const;
+
+export function getDefaultConfig() {
+  return {
+    ...DEFAULT_CONFIG_BASE,
+    projectDir: path.resolve(process.cwd(), DEFAULT_CONFIG_BASE.projectName),
+    packageManager: getUserPkgManager(),
+    frontend: [...DEFAULT_CONFIG_BASE.frontend],
+    addons: [...DEFAULT_CONFIG_BASE.addons],
+    examples: [...DEFAULT_CONFIG_BASE.examples],
+  };
+}
+
+export const DEFAULT_CONFIG = getDefaultConfig();
+
+export const dependencyVersionMap = {
+  typescript: "^5",
+
+  "better-auth": "^1.4.7",
+  "@better-auth/expo": "^1.4.7",
+
+  "@clerk/nextjs": "^6.31.5",
+  "@clerk/clerk-react": "^5.45.0",
+  "@clerk/tanstack-react-start": "^0.26.3",
+  "@clerk/clerk-expo": "^2.14.25",
+
+  "drizzle-orm": "^0.45.1",
+  "drizzle-kit": "^0.31.8",
+  "@planetscale/database": "^1.19.0",
+
+  "@libsql/client": "0.15.15",
+  libsql: "0.5.22",
+
+  "@neondatabase/serverless": "^1.0.2",
+  pg: "^8.16.3",
+  "@types/pg": "^8.15.6",
+  "@types/ws": "^8.18.1",
+  ws: "^8.18.3",
+
+  mysql2: "^3.14.0",
+
+  "@prisma/client": "^7.1.0",
+  prisma: "^7.1.0",
+  "@prisma/adapter-d1": "^7.1.0",
+  "@prisma/adapter-neon": "^7.1.0",
+  "@prisma/adapter-mariadb": "^7.1.0",
+  "@prisma/adapter-libsql": "^7.1.0",
+  "@prisma/adapter-better-sqlite3": "^7.1.0",
+  "@prisma/adapter-pg": "^7.1.0",
+  "@prisma/adapter-planetscale": "^7.1.0",
+
+  mongoose: "^8.14.0",
+
+  "vite-plugin-pwa": "^1.0.1",
+  "@vite-pwa/assets-generator": "^1.0.0",
+
+  "@tauri-apps/cli": "^2.4.0",
+
+  "@biomejs/biome": "^2.2.0",
+
+  oxlint: "^1.34.0",
+  oxfmt: "^0.19.0",
+
+  husky: "^9.1.7",
+  "lint-staged": "^16.1.2",
+
+  tsx: "^4.19.2",
+  "@types/node": "^22.13.11",
+
+  "@types/bun": "^1.3.4",
+
+  "@elysiajs/node": "^1.3.1",
+
+  "@elysiajs/cors": "^1.3.3",
+  "@elysiajs/trpc": "^1.1.0",
+  elysia: "^1.3.21",
+
+  "@hono/node-server": "^1.14.4",
+  "@hono/trpc-server": "^0.4.0",
+  hono: "^4.8.2",
+
+  cors: "^2.8.5",
+  express: "^5.1.0",
+  "@types/express": "^5.0.1",
+  "@types/cors": "^2.8.17",
+
+  fastify: "^5.3.3",
+  "@fastify/cors": "^11.0.1",
+
+  turbo: "^2.6.3",
+
+  ai: "^5.0.49",
+  "@ai-sdk/google": "^2.0.51",
+  "@ai-sdk/vue": "^2.0.49",
+  "@ai-sdk/svelte": "^3.0.39",
+  "@ai-sdk/react": "^2.0.39",
+  streamdown: "^1.6.10",
+  shiki: "^3.12.2",
+
+  "@orpc/server": "^1.12.2",
+  "@orpc/client": "^1.12.2",
+  "@orpc/openapi": "^1.12.2",
+  "@orpc/zod": "^1.12.2",
+  "@orpc/tanstack-query": "^1.12.2",
+
+  "@trpc/tanstack-react-query": "^11.7.2",
+  "@trpc/server": "^11.7.2",
+  "@trpc/client": "^11.7.2",
+
+  next: "^16.0.10",
+
+  convex: "^1.31.2",
+  "@convex-dev/react-query": "^0.1.0",
+  "@convex-dev/agent": "^0.3.2",
+  "convex-svelte": "^0.0.12",
+  "convex-nuxt": "0.1.5",
+  "convex-vue": "^0.1.5",
+  "@convex-dev/better-auth": "^0.10.6",
+
+  "@tanstack/svelte-query": "^5.85.3",
+  "@tanstack/svelte-query-devtools": "^5.85.3",
+
+  "@tanstack/vue-query-devtools": "^5.90.2",
+  "@tanstack/vue-query": "^5.90.2",
+
+  "@tanstack/react-query-devtools": "^5.91.1",
+  "@tanstack/react-query": "^5.90.12",
+
+  "@tanstack/solid-query": "^5.87.4",
+  "@tanstack/solid-query-devtools": "^5.87.4",
+  "@tanstack/solid-router-devtools": "^1.131.44",
+
+  wrangler: "^4.54.0",
+  "@cloudflare/vite-plugin": "^1.17.1",
+  "@opennextjs/cloudflare": "^1.14.6",
+  "nitro-cloudflare-dev": "^0.2.2",
+  "@sveltejs/adapter-cloudflare": "^7.2.4",
+  "@cloudflare/workers-types": "^4.20251213.0",
+
+  alchemy: "^0.81.2",
+
+  dotenv: "^17.2.2",
+  tsdown: "^0.16.5",
+  zod: "^4.1.13",
+  srvx: "0.8.15",
+
+  "@polar-sh/better-auth": "^1.1.3",
+  "@polar-sh/sdk": "^0.34.16",
+} as const;
+
+export type AvailableDependencies = keyof typeof dependencyVersionMap;
+
+export const ADDON_COMPATIBILITY = {
+  pwa: ["tanstack-router", "react-router", "solid", "next"],
+  tauri: ["tanstack-router", "react-router", "nuxt", "svelte", "solid", "next"],
+  biome: [],
+  husky: [],
+  turborepo: [],
+  starlight: [],
+  ultracite: [],
+  ruler: [],
+  oxlint: [],
+  fumadocs: [],
+  opentui: [],
+  wxt: [],
+  none: [],
+} as const;

package/src/helpers/addons/addons-setup.ts

@@ -0,0 +1,201 @@
+import path from "node:path";
+import { log } from "@clack/prompts";
+import fs from "fs-extra";
+import pc from "picocolors";
+import type { Frontend, ProjectConfig } from "../../types";
+import { addPackageDependency } from "../../utils/add-package-deps";
+import { setupFumadocs } from "./fumadocs-setup";
+import { setupOxlint } from "./oxlint-setup";
+import { setupRuler } from "./ruler-setup";
+import { setupStarlight } from "./starlight-setup";
+import { setupTauri } from "./tauri-setup";
+import { setupTui } from "./tui-setup";
+import { setupUltracite } from "./ultracite-setup";
+import { setupWxt } from "./wxt-setup";
+import { addPwaToViteConfig } from "./vite-pwa-setup";
+
+export async function setupAddons(config: ProjectConfig, isAddCommand = false) {
+  const { addons, frontend, projectDir, packageManager } = config;
+  const hasReactWebFrontend =
+    frontend.includes("react-router") ||
+    frontend.includes("tanstack-router") ||
+    frontend.includes("next");
+  const hasNuxtFrontend = frontend.includes("nuxt");
+  const hasSvelteFrontend = frontend.includes("svelte");
+  const hasSolidFrontend = frontend.includes("solid");
+  const hasNextFrontend = frontend.includes("next");
+
+  if (addons.includes("turborepo")) {
+    await addPackageDependency({
+      devDependencies: ["turbo"],
+      projectDir,
+    });
+
+    if (isAddCommand) {
+      log.info(`${pc.yellow("Update your package.json scripts:")}
+
+${pc.dim("Replace:")} ${pc.yellow('"pnpm -r dev"')} ${pc.dim("→")} ${pc.green('"turbo dev"')}
+${pc.dim("Replace:")} ${pc.yellow('"pnpm --filter web dev"')} ${pc.dim(
+        "→",
+      )} ${pc.green('"turbo -F web dev"')}
+
+${pc.cyan("Docs:")} ${pc.underline("https://turborepo.com/docs")}
+		`);
+    }
+  }
+
+  if (addons.includes("pwa") && (hasReactWebFrontend || hasSolidFrontend)) {
+    await setupPwa(projectDir, frontend);
+  }
+  if (
+    addons.includes("tauri") &&
+    (hasReactWebFrontend ||
+      hasNuxtFrontend ||
+      hasSvelteFrontend ||
+      hasSolidFrontend ||
+      hasNextFrontend)
+  ) {
+    await setupTauri(config);
+  }
+  const hasUltracite = addons.includes("ultracite");
+  const hasBiome = addons.includes("biome");
+  const hasHusky = addons.includes("husky");
+  const hasOxlint = addons.includes("oxlint");
+
+  if (hasUltracite) {
+    await setupUltracite(config, hasHusky);
+  } else {
+    if (hasBiome) {
+      await setupBiome(projectDir);
+    }
+    if (hasHusky) {
+      let linter: "biome" | "oxlint" | undefined;
+      if (hasOxlint) {
+        linter = "oxlint";
+      } else if (hasBiome) {
+        linter = "biome";
+      }
+      await setupHusky(projectDir, linter);
+    }
+  }
+
+  if (hasOxlint) {
+    await setupOxlint(projectDir, packageManager);
+  }
+  if (addons.includes("starlight")) {
+    await setupStarlight(config);
+  }
+
+  if (addons.includes("ruler")) {
+    await setupRuler(config);
+  }
+  if (addons.includes("fumadocs")) {
+    await setupFumadocs(config);
+  }
+  if (addons.includes("opentui")) {
+    await setupTui(config);
+  }
+  if (addons.includes("wxt")) {
+    await setupWxt(config);
+  }
+}
+
+function getWebAppDir(projectDir: string, frontends: Frontend[]) {
+  if (
+    frontends.some((f) =>
+      ["react-router", "tanstack-router", "nuxt", "svelte", "solid"].includes(f),
+    )
+  ) {
+    return path.join(projectDir, "apps/web");
+  }
+  return path.join(projectDir, "apps/web");
+}
+
+export async function setupBiome(projectDir: string) {
+  await addPackageDependency({
+    devDependencies: ["@biomejs/biome"],
+    projectDir,
+  });
+
+  const packageJsonPath = path.join(projectDir, "package.json");
+  if (await fs.pathExists(packageJsonPath)) {
+    const packageJson = await fs.readJson(packageJsonPath);
+
+    packageJson.scripts = {
+      ...packageJson.scripts,
+      check: "biome check --write .",
+    };
+
+    await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+  }
+}
+
+export async function setupHusky(projectDir: string, linter?: "biome" | "oxlint") {
+  await addPackageDependency({
+    devDependencies: ["husky", "lint-staged"],
+    projectDir,
+  });
+
+  const packageJsonPath = path.join(projectDir, "package.json");
+  if (await fs.pathExists(packageJsonPath)) {
+    const packageJson = await fs.readJson(packageJsonPath);
+
+    packageJson.scripts = {
+      ...packageJson.scripts,
+      prepare: "husky",
+    };
+
+    if (linter === "oxlint") {
+      packageJson["lint-staged"] = {
+        "*": ["oxlint", "oxfmt --write"],
+      };
+    } else if (linter === "biome") {
+      packageJson["lint-staged"] = {
+        "*.{js,ts,cjs,mjs,d.cts,d.mts,jsx,tsx,json,jsonc}": ["biome check --write ."],
+      };
+    } else {
+      packageJson["lint-staged"] = {
+        "**/*.{js,mjs,cjs,jsx,ts,mts,cts,tsx,vue,astro,svelte}": "",
+      };
+    }
+
+    await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+  }
+}
+
+async function setupPwa(projectDir: string, frontends: Frontend[]) {
+  const isCompatibleFrontend = frontends.some((f) =>
+    ["react-router", "tanstack-router", "solid"].includes(f),
+  );
+  if (!isCompatibleFrontend) return;
+
+  const clientPackageDir = getWebAppDir(projectDir, frontends);
+
+  if (!(await fs.pathExists(clientPackageDir))) {
+    return;
+  }
+
+  await addPackageDependency({
+    dependencies: ["vite-plugin-pwa"],
+    devDependencies: ["@vite-pwa/assets-generator"],
+    projectDir: clientPackageDir,
+  });
+
+  const clientPackageJsonPath = path.join(clientPackageDir, "package.json");
+  if (await fs.pathExists(clientPackageJsonPath)) {
+    const packageJson = await fs.readJson(clientPackageJsonPath);
+
+    packageJson.scripts = {
+      ...packageJson.scripts,
+      "generate-pwa-assets": "pwa-assets-generator",
+    };
+
+    await fs.writeJson(clientPackageJsonPath, packageJson, { spaces: 2 });
+  }
+
+  const viteConfigTs = path.join(clientPackageDir, "vite.config.ts");
+
+  if (await fs.pathExists(viteConfigTs)) {
+    await addPwaToViteConfig(viteConfigTs, path.basename(projectDir));
+  }
+}

package/src/helpers/addons/examples-setup.ts

@@ -0,0 +1,137 @@
+import path from "node:path";
+import fs from "fs-extra";
+import type { AvailableDependencies } from "../../constants";
+import type { ProjectConfig } from "../../types";
+import { addPackageDependency } from "../../utils/add-package-deps";
+
+export async function setupExamples(config: ProjectConfig) {
+  const { examples, backend } = config;
+
+  if (!examples || examples.length === 0 || examples[0] === "none") {
+    return;
+  }
+
+  if (examples.includes("todo") && backend !== "convex" && backend !== "none") {
+    await setupTodoDependencies(config);
+  }
+
+  if (examples.includes("ai")) {
+    await setupAIDependencies(config);
+  }
+}
+
+async function setupTodoDependencies(config: ProjectConfig) {
+  const { projectDir, orm, database, backend } = config;
+
+  const apiDir = path.join(projectDir, "packages/api");
+  const apiDirExists = await fs.pathExists(apiDir);
+
+  if (!apiDirExists || backend === "none") {
+    return;
+  }
+
+  if (orm === "drizzle") {
+    const dependencies: AvailableDependencies[] = ["drizzle-orm"];
+    if (database === "postgres") {
+      dependencies.push("@types/pg");
+    }
+    await addPackageDependency({
+      dependencies,
+      projectDir: apiDir,
+    });
+  } else if (orm === "prisma") {
+    await addPackageDependency({
+      dependencies: ["@prisma/client"],
+      projectDir: apiDir,
+    });
+  } else if (orm === "mongoose") {
+    await addPackageDependency({
+      dependencies: ["mongoose"],
+      projectDir: apiDir,
+    });
+  }
+}
+
+async function setupAIDependencies(config: ProjectConfig) {
+  const { frontend, backend, projectDir } = config;
+
+  const webClientDir = path.join(projectDir, "apps/web");
+  const nativeClientDir = path.join(projectDir, "apps/native");
+  const serverDir = path.join(projectDir, "apps/server");
+  const convexBackendDir = path.join(projectDir, "packages/backend");
+
+  const webClientDirExists = await fs.pathExists(webClientDir);
+  const nativeClientDirExists = await fs.pathExists(nativeClientDir);
+  const serverDirExists = await fs.pathExists(serverDir);
+  const convexBackendDirExists = await fs.pathExists(convexBackendDir);
+
+  const hasReactWeb =
+    frontend.includes("react-router") ||
+    frontend.includes("tanstack-router") ||
+    frontend.includes("next") ||
+    frontend.includes("tanstack-start");
+  const hasNuxt = frontend.includes("nuxt");
+  const hasSvelte = frontend.includes("svelte");
+
+  const hasReactNative =
+    frontend.includes("native-bare") ||
+    frontend.includes("native-uniwind") ||
+    frontend.includes("native-unistyles");
+
+  if (backend === "convex" && convexBackendDirExists) {
+    await addPackageDependency({
+      dependencies: ["@convex-dev/agent", "ai", "@ai-sdk/google"],
+      projectDir: convexBackendDir,
+    });
+  } else if (backend === "self" && webClientDirExists) {
+    await addPackageDependency({
+      dependencies: ["ai", "@ai-sdk/google"],
+      projectDir: webClientDir,
+    });
+  } else if (serverDirExists && backend !== "none") {
+    await addPackageDependency({
+      dependencies: ["ai", "@ai-sdk/google"],
+      projectDir: serverDir,
+    });
+  }
+
+  if (webClientDirExists) {
+    const dependencies: AvailableDependencies[] = [];
+
+    if (backend === "convex") {
+      if (hasReactWeb) {
+        dependencies.push("@convex-dev/agent", "streamdown");
+      }
+    } else {
+      dependencies.push("ai");
+      if (hasNuxt) {
+        dependencies.push("@ai-sdk/vue");
+      } else if (hasSvelte) {
+        dependencies.push("@ai-sdk/svelte");
+      } else if (hasReactWeb) {
+        dependencies.push("@ai-sdk/react", "streamdown");
+      }
+    }
+
+    if (dependencies.length > 0) {
+      await addPackageDependency({
+        dependencies,
+        projectDir: webClientDir,
+      });
+    }
+  }
+
+  if (nativeClientDirExists && hasReactNative) {
+    if (backend === "convex") {
+      await addPackageDependency({
+        dependencies: ["@convex-dev/agent"],
+        projectDir: nativeClientDir,
+      });
+    } else {
+      await addPackageDependency({
+        dependencies: ["ai", "@ai-sdk/react"],
+        projectDir: nativeClientDir,
+      });
+    }
+  }
+}

package/src/helpers/addons/fumadocs-setup.ts

@@ -0,0 +1,99 @@
+import path from "node:path";
+import { isCancel, log, select, spinner } from "@clack/prompts";
+import consola from "consola";
+import { $ } from "bun";
+import fs from "fs-extra";
+import pc from "picocolors";
+import type { ProjectConfig } from "../../types";
+import { exitCancelled } from "../../utils/errors";
+import { getPackageExecutionCommand } from "../../utils/package-runner";
+
+type FumadocsTemplate =
+  | "next-mdx"
+  | "waku"
+  | "react-router"
+  | "react-router-spa"
+  | "tanstack-start";
+
+const TEMPLATES = {
+  "next-mdx": {
+    label: "Next.js: Fumadocs MDX",
+    hint: "Recommended template with MDX support",
+    value: "+next+fuma-docs-mdx",
+  },
+  waku: {
+    label: "Waku: Content Collections",
+    hint: "Template using Waku with content collections",
+    value: "waku",
+  },
+  "react-router": {
+    label: "React Router: MDX Remote",
+    hint: "Template for React Router with MDX remote",
+    value: "react-router",
+  },
+  "react-router-spa": {
+    label: "React Router: SPA",
+    hint: "Template for React Router SPA",
+    value: "react-router-spa",
+  },
+  "tanstack-start": {
+    label: "Tanstack Start: MDX Remote",
+    hint: "Template for Tanstack Start with MDX remote",
+    value: "tanstack-start",
+  },
+} as const;
+
+export async function setupFumadocs(config: ProjectConfig) {
+  const { packageManager, projectDir } = config;
+
+  try {
+    log.info("Setting up Fumadocs...");
+
+    const template = await select<FumadocsTemplate>({
+      message: "Choose a template",
+      options: Object.entries(TEMPLATES).map(([key, template]) => ({
+        value: key as FumadocsTemplate,
+        label: template.label,
+        hint: template.hint,
+      })),
+      initialValue: "next-mdx",
+    });
+
+    if (isCancel(template)) return exitCancelled("Operation cancelled");
+
+    const templateArg = TEMPLATES[template].value;
+
+    const commandWithArgs = `create-fumadocs-app@latest fumadocs --template ${templateArg} --src --pm ${packageManager} --no-git`;
+
+    const fumadocsInitCommand = getPackageExecutionCommand(packageManager, commandWithArgs);
+
+    const appsDir = path.join(projectDir, "apps");
+    await fs.ensureDir(appsDir);
+
+    const s = spinner();
+    s.start("Running Fumadocs create command...");
+
+    await $`${{ raw: fumadocsInitCommand }}`.cwd(appsDir).env({ CI: "true" });
+
+    const fumadocsDir = path.join(projectDir, "apps", "fumadocs");
+    const packageJsonPath = path.join(fumadocsDir, "package.json");
+
+    if (await fs.pathExists(packageJsonPath)) {
+      const packageJson = await fs.readJson(packageJsonPath);
+      packageJson.name = "fumadocs";
+
+      if (packageJson.scripts?.dev) {
+        packageJson.scripts.dev = `${packageJson.scripts.dev} --port=4000`;
+      }
+
+      await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
+
+    s.stop("Fumadocs setup complete!");
+  } catch (error) {
+    log.error(pc.red("Failed to set up Fumadocs"));
+    if (error instanceof Error) {
+      consola.error(pc.red(error.message));
+    }
+  }
+}