authverse 1.1.9 → 1.1.10

package/dist/index.js

@@ -4,7 +4,7 @@
 import { Command } from "commander";
 
 // cli/init.ts
-import inquirer3 from "inquirer";
+import inquirer4 from "inquirer";
 
 // script/prisma.ts
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -423,24 +423,40 @@ ${CreateFolder({ srcFolder, destFolder: "proxy.ts" })}
 };
 
 // script/drizzleRun.ts
+import chalk5 from "chalk";
+import path5 from "path";
+import fs5 from "fs";
+
+// drizzle/drizzleNextSetup.ts
 import chalk3 from "chalk";
 import path3 from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
 import fs3 from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
 import inquirer2 from "inquirer";
-var drizzleRun = async ({ authUi, cmd }) => {
+var drizzleNextSetup = async ({
+  authUi,
+  cmd,
+  projectDir
+}) => {
   try {
-    const projectDir = process.cwd();
     const packageJsonPath = path3.join(projectDir, "package.json");
     const packageJson2 = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
     if (!packageJson2.dependencies["better-auth"]) {
       console.log(chalk3.cyan("\n\u2699\uFE0F  Initializing better auth...\n"));
       packageManager("better-auth");
     }
-    if (!packageJson2.dependencies["drizzle-orm"] && !packageJson2.dependencies["drizzle-orm"] && !packageJson2.dependencies["drizzle-kit"] && !packageJson2.devDependencies["drizzle-kit"]) {
+    const drizzleDeps = [
+      "drizzle-orm",
+      "@neondatabase/serverless",
+      "dotenv",
+      "drizzle-kit"
+    ];
+    const missingDrizzleDeps = drizzleDeps.filter((dep) => {
+      return !packageJson2.dependencies?.[dep] && !packageJson2.devDependencies?.[dep];
+    });
+    if (missingDrizzleDeps.length > 0) {
       console.log(chalk3.cyan("\n\u2699\uFE0F  Initializing drizzle...\n"));
-      packageManager("drizzle-orm @neondatabase/serverless dotenv");
-      packageManager("drizzle-kit", true);
+      packageManager(missingDrizzleDeps.join(" "));
     }
     const __filename = fileURLToPath3(import.meta.url);
     const __dirname = path3.dirname(__filename);
@@ -598,22 +614,316 @@ ${CreateFolder({ srcFolder, destFolder: "proxy.ts" })}
         )
       );
     }
+  } catch (error) {
+    console.error(chalk3.red("Drizzle setup failed:"), error);
+  }
+};
+
+// drizzle/drizzleNextChecker.ts
+import path4 from "path";
+import chalk4 from "chalk";
+import fs4 from "fs";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import inquirer3 from "inquirer";
+
+// drizzle/drizzle-utils.ts
+var extractColumnNames = (tableDef) => {
+  const columns = [];
+  const lines = tableDef.split("\n");
+  for (const line of lines) {
+    const columnMatch = line.match(/^\s*(\w+):/);
+    if (columnMatch && !line.includes("//") && !line.includes("export const")) {
+      columns.push(columnMatch[1]);
+    }
+  }
+  return columns;
+};
+var extractTableDefinition = (content, tableName) => {
+  const tableRegex = new RegExp(
+    `export const ${tableName} = pgTable\\(["']${tableName}["'][\\s\\S]*?\\n\\}\\);`,
+    "m"
+  );
+  const match = content.match(tableRegex);
+  return match ? match[0] : null;
+};
+var addMissingColumnsToTable = (existingTableDef, templateTableDef) => {
+  const existingColumns = extractColumnNames(existingTableDef);
+  const templateColumns = extractColumnNames(templateTableDef);
+  const missingColumns = templateColumns.filter(
+    (col) => !existingColumns.includes(col)
+  );
+  if (missingColumns.length === 0) {
+    return existingTableDef;
+  }
+  const lines = templateTableDef.split("\n");
+  const columnDefinitions = [];
+  for (const line of lines) {
+    for (const col of missingColumns) {
+      if (line.trim().startsWith(`${col}:`)) {
+        columnDefinitions.push(line);
+        break;
+      }
+    }
+  }
+  const existingLines = existingTableDef.split("\n");
+  const insertPosition = existingLines.length - 1;
+  for (const colDef of columnDefinitions) {
+    existingLines.splice(insertPosition, 0, `  ${colDef.trim()}`);
+  }
+  return existingLines.join("\n");
+};
+
+// drizzle/drizzleNextChecker.ts
+var drizzleNextChecker = async ({
+  authUi,
+  cmd,
+  projectDir
+}) => {
+  try {
+    const drizzleConfigPath = path4.join(projectDir, "drizzle.config.ts");
+    if (!fs4.existsSync(drizzleConfigPath)) {
+      return await drizzleNextSetup({ authUi, cmd, projectDir });
+    }
+    const drizzleConfigContent = fs4.readFileSync(drizzleConfigPath, "utf-8");
+    const schemaMatch = drizzleConfigContent.match(/schema:\s*["'`](.*?)["'`]/);
+    const schemaPath = schemaMatch ? schemaMatch[1] : null;
+    if (!schemaPath || schemaPath === "") {
+      return await drizzleNextSetup({ authUi, cmd, projectDir });
+    }
+    const __filename = fileURLToPath4(import.meta.url);
+    const __dirname = path4.dirname(__filename);
+    const dbTemplatePath = path4.resolve(__dirname, "./template/db/schema.ts");
+    const schemaFilePath = path4.join(projectDir, schemaPath);
+    if (!fs4.existsSync(schemaFilePath)) {
+      const dbFolder = path4.dirname(schemaFilePath);
+      if (!fs4.existsSync(dbFolder)) {
+        fs4.mkdirSync(dbFolder, { recursive: true });
+      }
+      fs4.copyFileSync(dbTemplatePath, schemaFilePath);
+    } else {
+      let schemaFileContent = fs4.readFileSync(schemaFilePath, "utf-8");
+      const dbTemplateContent = fs4.readFileSync(dbTemplatePath, "utf-8");
+      const requiredTables = ["user", "session", "account", "verification"];
+      let needsUpdate = false;
+      let updatedSchemaContent = schemaFileContent;
+      for (const table of requiredTables) {
+        const existingTable = extractTableDefinition(
+          updatedSchemaContent,
+          table
+        );
+        const templateTable = extractTableDefinition(dbTemplateContent, table);
+        if (!existingTable && templateTable) {
+          const schemaExportIndex = updatedSchemaContent.indexOf(
+            "export const schema ="
+          );
+          if (schemaExportIndex !== -1) {
+            updatedSchemaContent = updatedSchemaContent.slice(0, schemaExportIndex) + templateTable + "\n\n" + updatedSchemaContent.slice(schemaExportIndex);
+          } else {
+            updatedSchemaContent += "\n\n" + templateTable;
+          }
+          needsUpdate = true;
+        } else if (existingTable && templateTable) {
+          const existingColumns = extractColumnNames(existingTable);
+          const templateColumns = extractColumnNames(templateTable);
+          const missingColumns = templateColumns.filter(
+            (col) => !existingColumns.includes(col)
+          );
+          if (missingColumns.length > 0) {
+            const updatedTable = addMissingColumnsToTable(
+              existingTable,
+              templateTable
+            );
+            updatedSchemaContent = updatedSchemaContent.replace(
+              existingTable,
+              updatedTable
+            );
+            needsUpdate = true;
+          }
+        }
+      }
+      if (needsUpdate) {
+        const schemaExportRegex = /export const schema = \{([\s\S]*?)\};/;
+        const schemaMatch2 = updatedSchemaContent.match(schemaExportRegex);
+        if (schemaMatch2) {
+          let currentSchemaContent = schemaMatch2[1];
+          for (const table of requiredTables) {
+            if (!currentSchemaContent.includes(`${table},`)) {
+              const lines = currentSchemaContent.split("\n");
+              const lastNonEmptyLine = lines.length - 1;
+              if (lines[lastNonEmptyLine].trim() === "}") {
+                lines[lastNonEmptyLine] = `  ${table},
+${lines[lastNonEmptyLine]}`;
+              } else {
+                lines.push(`  ${table},`);
+              }
+              currentSchemaContent = lines.join("\n");
+            }
+          }
+          updatedSchemaContent = updatedSchemaContent.replace(
+            schemaExportRegex,
+            `export const schema = {${currentSchemaContent}};`
+          );
+        }
+        fs4.writeFileSync(schemaFilePath, updatedSchemaContent);
+      }
+    }
+    const packageJsonPath = path4.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(fs4.readFileSync(packageJsonPath, "utf-8"));
+    if (!packageJson2.dependencies["better-auth"]) {
+      console.log(chalk4.cyan("\n\u2699\uFE0F  Initializing better auth...\n"));
+      packageManager("better-auth");
+    }
+    const drizzleDeps = [
+      "drizzle-orm",
+      "@neondatabase/serverless",
+      "dotenv",
+      "drizzle-kit"
+    ];
+    const missingDrizzleDeps = drizzleDeps.filter((dep) => {
+      return !packageJson2.dependencies?.[dep] && !packageJson2.devDependencies?.[dep];
+    });
+    if (missingDrizzleDeps.length > 0) {
+      console.log(chalk4.cyan("\n\u2699\uFE0F  Initializing drizzle...\n"));
+      packageManager(missingDrizzleDeps.join(" "));
+    }
+    const envPath = path4.join(projectDir, ".env");
+    if (!fs4.existsSync(envPath)) {
+      fs4.writeFileSync(envPath, "DATABASE_URL=\n");
+    }
+    const secret = await GenerateSecret();
+    const envContent = fs4.readFileSync(envPath, "utf-8");
+    if (!envContent.includes("BETTER_AUTH_SECRET")) {
+      fs4.appendFileSync(envPath, `
+
+BETTER_AUTH_SECRET=${secret}`);
+    }
+    if (!envContent.includes("BETTER_AUTH_URL")) {
+      fs4.appendFileSync(envPath, `
+BETTER_AUTH_URL=http://localhost:3000
+`);
+    }
+    const srcFolder = fs4.existsSync(path4.join(projectDir, "src")) ? "src" : "";
+    const libPath = path4.join(projectDir, srcFolder, "lib");
+    if (!fs4.existsSync(libPath)) {
+      fs4.mkdirSync(libPath, { recursive: true });
+    }
+    const authPath = path4.join(libPath, "auth.ts");
+    const authClientPath = path4.join(libPath, "auth-client.ts");
+    if (fs4.existsSync(authPath) || fs4.existsSync(authClientPath)) {
+      const answers = await inquirer3.prompt([
+        {
+          type: "confirm",
+          name: "overwrite",
+          message: "Do you want to overwrite existing auth lib/auth.ts or lib/auth-client.ts",
+          default: false
+        }
+      ]);
+      if (answers.overwrite) {
+        const authTemplatePath = path4.resolve(
+          __dirname,
+          "./template/lib/auth-drizzle.ts"
+        );
+        const authDestinationPath = path4.join(libPath, "auth.ts");
+        fs4.copyFileSync(authTemplatePath, authDestinationPath);
+        const authClientTemplatePath = path4.resolve(
+          __dirname,
+          "./template/lib/auth-client.ts"
+        );
+        const authClientDestinationPath = path4.join(libPath, "auth-client.ts");
+        fs4.copyFileSync(authClientTemplatePath, authClientDestinationPath);
+      }
+    } else {
+      const authTemplatePath = path4.resolve(
+        __dirname,
+        "./template/lib/auth-drizzle.ts"
+      );
+      const authDestinationPath = path4.join(libPath, "auth.ts");
+      fs4.copyFileSync(authTemplatePath, authDestinationPath);
+      const authClientTemplatePath = path4.resolve(
+        __dirname,
+        "./template/lib/auth-client.ts"
+      );
+      const authClientDestinationPath = path4.join(libPath, "auth-client.ts");
+      fs4.copyFileSync(authClientTemplatePath, authClientDestinationPath);
+    }
+    const routeTemplatePath = path4.resolve(
+      __dirname,
+      "./template/api/route.ts"
+    );
+    const routeDestinationDir = path4.join(
+      projectDir,
+      srcFolder,
+      "app",
+      "api",
+      "auth",
+      "[...all]"
+    );
+    if (!fs4.existsSync(routeDestinationDir)) {
+      fs4.mkdirSync(routeDestinationDir, { recursive: true });
+    }
+    const routeDestinationPath = path4.join(routeDestinationDir, "route.ts");
+    fs4.copyFileSync(routeTemplatePath, routeDestinationPath);
+    const proxyTemplatePath = path4.resolve(
+      __dirname,
+      "./template/proxy/proxy.ts"
+    );
+    const proxyDestinationDir = path4.join(projectDir, srcFolder);
+    const proxyDestinationPath = path4.join(proxyDestinationDir, "proxy.ts");
+    fs4.copyFileSync(proxyTemplatePath, proxyDestinationPath);
+    if (authUi) {
+      await authUiRun({
+        folder: srcFolder,
+        packageJson: projectDir,
+        cmd,
+        database: "drizzle"
+      });
+    } else {
+      console.log(chalk4.green("\nCompleted installation successfully"));
+      console.log(chalk4.cyan("\nInstall Package:"));
+      console.log(chalk4.white(`\u2022 drizzle schema
+\u2022 better-auth`));
+      console.log(chalk4.cyan("\nFiles created:"));
+      console.log(
+        chalk4.white(
+          `${CreateFolder({ srcFolder, destFolder: "lib/auth.ts" })}
+${CreateFolder({ srcFolder, destFolder: "lib/auth-client.ts" })}
+${CreateFolder({ srcFolder, destFolder: "app/api/auth/[...all]/route.ts" })}
+${CreateFolder({ srcFolder, destFolder: "proxy.ts" })}
+`
+        )
+      );
+    }
+  } catch (error) {
+    console.error(chalk4.red("Error checking Drizzle setup:"), error);
+  }
+};
+
+// script/drizzleRun.ts
+var drizzleRun = async ({ authUi, cmd }) => {
+  try {
+    const projectDir = process.cwd();
+    const drizzleConfigPath = path5.join(projectDir, "drizzle.config.ts");
+    if (fs5.existsSync(drizzleConfigPath)) {
+      await drizzleNextChecker({ authUi, cmd, projectDir });
+    } else {
+      await drizzleNextSetup({ authUi, cmd, projectDir });
+    }
   } catch (err) {
-    console.error(chalk3.red("Drizzle setup failed:"), err);
+    console.error(chalk5.red("Drizzle setup failed:"), err);
   }
 };
 
 // script/prismaRunTanstackStart.ts
-import chalk5 from "chalk";
-import path5 from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
-import fs5 from "fs";
+import chalk7 from "chalk";
+import path7 from "path";
+import { fileURLToPath as fileURLToPath6 } from "url";
+import fs7 from "fs";
 
 // script/authUiTanstackState.ts
-import chalk4 from "chalk";
-import { fileURLToPath as fileURLToPath4 } from "url";
-import path4 from "path";
-import fs4 from "fs";
+import chalk6 from "chalk";
+import { fileURLToPath as fileURLToPath5 } from "url";
+import path6 from "path";
+import fs6 from "fs";
 var shadcnComponents2 = [
   "button.tsx",
   "card.tsx",
@@ -630,10 +940,10 @@ var authUiTanstackState = async ({
 }) => {
   try {
     const projectDir = process.cwd();
-    const shadcnPath = path4.join(projectDir, "src", "components", "ui");
-    const shadcnConfigPath = path4.join(projectDir, "components.json");
-    if (!fs4.existsSync(shadcnPath) || !fs4.existsSync(shadcnConfigPath)) {
-      console.log(chalk4.yellow("\n Installing shadcn ui Components\n"));
+    const shadcnPath = path6.join(projectDir, "src", "components", "ui");
+    const shadcnConfigPath = path6.join(projectDir, "components.json");
+    if (!fs6.existsSync(shadcnPath) || !fs6.existsSync(shadcnConfigPath)) {
+      console.log(chalk6.yellow("\n Installing shadcn ui Components\n"));
       if (cmd == true) {
         runCommand("shadcn@latest init");
         runCommand("shadcn@latest add button sonner card field input");
@@ -641,60 +951,60 @@ var authUiTanstackState = async ({
         runCommand("shadcn@latest add button sonner card field input");
       }
     }
-    const shadcnFiles = fs4.readdirSync(shadcnPath);
+    const shadcnFiles = fs6.readdirSync(shadcnPath);
     const missingComponents = shadcnComponents2.filter(
       (component) => !shadcnFiles.includes(component)
     );
     if (missingComponents.length > 0) {
-      console.log(chalk4.yellow("\n Installing shadcn ui Components\n"));
+      console.log(chalk6.yellow("\n Installing shadcn ui Components\n"));
       const install = missingComponents.map((components) => components.split(".")[0]).join(" ");
       runCommand(`shadcn@latest add ${install}`);
     }
     if (!packageJson2.dependencies?.["@tanstack/react-form"] || !packageJson2.dependencies?.["zod"]) {
       packageManager("@tanstack/react-form zod");
     }
-    const __filename = fileURLToPath4(import.meta.url);
-    const __dirname = path4.dirname(__filename);
-    const srcPath = path4.join(projectDir, "src");
-    const componentPath = path4.resolve(
+    const __filename = fileURLToPath5(import.meta.url);
+    const __dirname = path6.dirname(__filename);
+    const srcPath = path6.join(projectDir, "src");
+    const componentPath = path6.resolve(
       __dirname,
       "./template/TanstackStart/components"
     );
-    const authversePathComponents = path4.join(
+    const authversePathComponents = path6.join(
       srcPath,
       "components",
       "authverse"
     );
-    if (!fs4.existsSync(authversePathComponents)) {
-      fs4.mkdirSync(authversePathComponents, { recursive: true });
+    if (!fs6.existsSync(authversePathComponents)) {
+      fs6.mkdirSync(authversePathComponents, { recursive: true });
     }
-    fs4.copyFileSync(
+    fs6.copyFileSync(
       `${componentPath}/LoginComponent.tsx`,
-      path4.join(authversePathComponents, "LoginComponent.tsx")
+      path6.join(authversePathComponents, "LoginComponent.tsx")
     );
-    fs4.copyFileSync(
+    fs6.copyFileSync(
       `${componentPath}/SingUpComponent.tsx`,
-      path4.join(authversePathComponents, "SingUpComponent.tsx")
+      path6.join(authversePathComponents, "SingUpComponent.tsx")
     );
-    const pageRoutesPath = path4.join(`${srcPath}/routes`, "auth");
-    if (!fs4.existsSync(pageRoutesPath)) {
-      fs4.mkdirSync(pageRoutesPath, { recursive: true });
+    const pageRoutesPath = path6.join(`${srcPath}/routes`, "auth");
+    if (!fs6.existsSync(pageRoutesPath)) {
+      fs6.mkdirSync(pageRoutesPath, { recursive: true });
     }
-    const templateRoutesPage = path4.resolve(
+    const templateRoutesPage = path6.resolve(
       __dirname,
       "./template/TanstackStart/routes/auth"
     );
-    fs4.copyFileSync(
+    fs6.copyFileSync(
       `${templateRoutesPage}/login.tsx`,
-      path4.join(pageRoutesPath, "login.tsx")
+      path6.join(pageRoutesPath, "login.tsx")
     );
-    fs4.copyFileSync(
+    fs6.copyFileSync(
       `${templateRoutesPage}/signup.tsx`,
-      path4.join(pageRoutesPath, "signup.tsx")
+      path6.join(pageRoutesPath, "signup.tsx")
     );
-    const rootPath = path4.join(projectDir, "src/routes", "__root.tsx");
-    if (fs4.existsSync(rootPath)) {
-      let rootContent = fs4.readFileSync(rootPath, "utf-8");
+    const rootPath = path6.join(projectDir, "src/routes", "__root.tsx");
+    if (fs6.existsSync(rootPath)) {
+      let rootContent = fs6.readFileSync(rootPath, "utf-8");
       if (!rootContent.includes("Toaster")) {
         rootContent = `import { Toaster } from "@/components/ui/sonner";
 ${rootContent}`;
@@ -705,15 +1015,15 @@ ${rootContent}`;
           "    <Toaster />\n  </body>"
         );
       }
-      fs4.writeFileSync(rootPath, rootContent, "utf-8");
+      fs6.writeFileSync(rootPath, rootContent, "utf-8");
     }
-    console.log(chalk4.green("\nCompleted installation successfully"));
-    console.log(chalk4.cyan("\nInstall Package:"));
-    console.log(chalk4.white(`\u2022 ${database} schema
+    console.log(chalk6.green("\nCompleted installation successfully"));
+    console.log(chalk6.cyan("\nInstall Package:"));
+    console.log(chalk6.white(`\u2022 ${database} schema
 \u2022 better-auth`));
-    console.log(chalk4.cyan("\nFiles created:"));
+    console.log(chalk6.cyan("\nFiles created:"));
     console.log(
-      chalk4.white(
+      chalk6.white(
         `\u2022 src/lib/auth.ts
 \u2022 src/lib/auth-client.ts
 \u2022 src/app/api/auth/[...all]/route.ts
@@ -727,7 +1037,7 @@ ${rootContent}`;
       )
     );
   } catch (error) {
-    console.log(chalk4.red("Auth Ui Tanstack State Error: ", error));
+    console.log(chalk6.red("Auth Ui Tanstack State Error: ", error));
   }
 };
 
@@ -739,12 +1049,12 @@ var prismaRunTanstackStart = async ({
 }) => {
   try {
     const projectDir = process.cwd();
-    const __filename = fileURLToPath5(import.meta.url);
-    const __dirname = path5.dirname(__filename);
-    const packageJsonPath = path5.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(fs5.readFileSync(packageJsonPath, "utf-8"));
+    const __filename = fileURLToPath6(import.meta.url);
+    const __dirname = path7.dirname(__filename);
+    const packageJsonPath = path7.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(fs7.readFileSync(packageJsonPath, "utf-8"));
     if (!packageJson2.devDependencies?.prisma || !packageJson2.dependencies?.["@prisma/client"]) {
-      console.log(chalk5.cyan("\n\u2699\uFE0F  Initializing Prisma...\n"));
+      console.log(chalk7.cyan("\n\u2699\uFE0F  Initializing Prisma...\n"));
       if (database !== "Mongodb") {
         packageManager("prisma", true);
         packageManager("@prisma/client");
@@ -759,98 +1069,98 @@ var prismaRunTanstackStart = async ({
         packageManager("@prisma/client@6.19.0");
       }
     }
-    const prismaDir = path5.join(projectDir, "prisma");
-    if (!fs5.existsSync(prismaDir)) {
-      console.log(chalk5.yellow("\n\u2699\uFE0F  Initializing Prisma...\n"));
+    const prismaDir = path7.join(projectDir, "prisma");
+    if (!fs7.existsSync(prismaDir)) {
+      console.log(chalk7.yellow("\n\u2699\uFE0F  Initializing Prisma...\n"));
       runCommand("prisma init");
-      const templatePath = path5.resolve(
+      const templatePath = path7.resolve(
         __dirname,
         `./template/prisma/${database}/schema.prisma`
       );
-      if (!fs5.existsSync(prismaDir)) {
-        fs5.mkdirSync(prismaDir, { recursive: true });
+      if (!fs7.existsSync(prismaDir)) {
+        fs7.mkdirSync(prismaDir, { recursive: true });
       }
-      const destinationPath = path5.join(prismaDir, "schema.prisma");
-      fs5.copyFileSync(templatePath, destinationPath);
+      const destinationPath = path7.join(prismaDir, "schema.prisma");
+      fs7.copyFileSync(templatePath, destinationPath);
       if (database === "Mongodb") {
-        const prismaConfigPath = path5.resolve(
+        const prismaConfigPath = path7.resolve(
           __dirname,
           `./template/config/prisma.config.ts`
         );
-        const prismaConfigDestinationPath = path5.join("", "prisma.config.ts");
-        fs5.copyFileSync(prismaConfigPath, prismaConfigDestinationPath);
+        const prismaConfigDestinationPath = path7.join("", "prisma.config.ts");
+        fs7.copyFileSync(prismaConfigPath, prismaConfigDestinationPath);
       }
     } else {
-      const schemaPath = path5.join(prismaDir, "schema.prisma");
-      const schemaContent = fs5.readFileSync(schemaPath, "utf-8");
+      const schemaPath = path7.join(prismaDir, "schema.prisma");
+      const schemaContent = fs7.readFileSync(schemaPath, "utf-8");
       if (!schemaContent.includes("User") || !schemaContent.includes("Session") || !schemaContent.includes("Account") || !schemaContent.includes("Verification")) {
-        const templatePath = path5.resolve(
+        const templatePath = path7.resolve(
           __dirname,
           `./template/prisma/${database}/schema.prisma_copy`
         );
-        fs5.appendFileSync(schemaPath, "\n");
-        fs5.appendFileSync(schemaPath, fs5.readFileSync(templatePath));
+        fs7.appendFileSync(schemaPath, "\n");
+        fs7.appendFileSync(schemaPath, fs7.readFileSync(templatePath));
       }
     }
     if (!packageJson2.dependencies?.["better-auth"]) {
-      console.log(chalk5.yellow("\n\u2699\uFE0F  Initializing better-auth...\n"));
+      console.log(chalk7.yellow("\n\u2699\uFE0F  Initializing better-auth...\n"));
       packageManager("better-auth");
     }
     const secret = await GenerateSecret();
-    const envPath = path5.join(projectDir, ".env");
-    const envContent = fs5.readFileSync(envPath, "utf-8");
+    const envPath = path7.join(projectDir, ".env");
+    const envContent = fs7.readFileSync(envPath, "utf-8");
     if (!envContent.includes("BETTER_AUTH_SECRET")) {
-      fs5.appendFileSync(envPath, `
+      fs7.appendFileSync(envPath, `
 
 BETTER_AUTH_SECRET=${secret}`);
     }
     if (!envContent.includes("BETTER_AUTH_URL")) {
-      fs5.appendFileSync(envPath, `
+      fs7.appendFileSync(envPath, `
 BETTER_AUTH_URL=http://localhost:3000
 `);
     }
-    const srcPath = path5.join(projectDir, "src");
-    const libPath = path5.join(srcPath, "lib");
-    if (!fs5.existsSync(libPath)) {
-      fs5.mkdirSync(libPath, { recursive: true });
+    const srcPath = path7.join(projectDir, "src");
+    const libPath = path7.join(srcPath, "lib");
+    if (!fs7.existsSync(libPath)) {
+      fs7.mkdirSync(libPath, { recursive: true });
     }
-    const authTemplatePath = path5.resolve(
+    const authTemplatePath = path7.resolve(
       __dirname,
       `./template/TanstackStart/lib/${database}/auth.ts`
     );
-    const authDestinationPath = path5.join(libPath, "auth.ts");
-    fs5.copyFileSync(authTemplatePath, authDestinationPath);
-    const authClientTemplatePath = path5.resolve(
+    const authDestinationPath = path7.join(libPath, "auth.ts");
+    fs7.copyFileSync(authTemplatePath, authDestinationPath);
+    const authClientTemplatePath = path7.resolve(
       __dirname,
       "./template/lib/auth-client.ts"
     );
-    const authClientDestinationPath = path5.join(libPath, "auth-client.ts");
-    fs5.copyFileSync(authClientTemplatePath, authClientDestinationPath);
-    const middlewarePath = path5.join(srcPath, "middleware");
-    if (!fs5.existsSync(middlewarePath)) {
-      fs5.mkdirSync(middlewarePath, { recursive: true });
+    const authClientDestinationPath = path7.join(libPath, "auth-client.ts");
+    fs7.copyFileSync(authClientTemplatePath, authClientDestinationPath);
+    const middlewarePath = path7.join(srcPath, "middleware");
+    if (!fs7.existsSync(middlewarePath)) {
+      fs7.mkdirSync(middlewarePath, { recursive: true });
     }
-    const authMiddlewareTemplatePath = path5.resolve(
+    const authMiddlewareTemplatePath = path7.resolve(
       __dirname,
       `./template/TanstackStart/middleware/auth.ts`
     );
-    const authMiddlewareDestinationPath = path5.join(middlewarePath, "auth.ts");
-    fs5.copyFileSync(authMiddlewareTemplatePath, authMiddlewareDestinationPath);
-    const fileRouteTemplatePath = path5.resolve(
+    const authMiddlewareDestinationPath = path7.join(middlewarePath, "auth.ts");
+    fs7.copyFileSync(authMiddlewareTemplatePath, authMiddlewareDestinationPath);
+    const fileRouteTemplatePath = path7.resolve(
       __dirname,
       `./template/TanstackStart/routes/$.ts`
     );
-    const fileRouteDestinationPath = path5.join(
+    const fileRouteDestinationPath = path7.join(
       srcPath,
       "routes",
       "api",
       "auth"
     );
-    if (!fs5.existsSync(fileRouteDestinationPath)) {
-      fs5.mkdirSync(fileRouteDestinationPath, { recursive: true });
+    if (!fs7.existsSync(fileRouteDestinationPath)) {
+      fs7.mkdirSync(fileRouteDestinationPath, { recursive: true });
     }
-    const apiDestinationPath = path5.join(fileRouteDestinationPath, "$.ts");
-    fs5.copyFileSync(fileRouteTemplatePath, apiDestinationPath);
+    const apiDestinationPath = path7.join(fileRouteDestinationPath, "$.ts");
+    fs7.copyFileSync(fileRouteTemplatePath, apiDestinationPath);
     if (authUi) {
       await authUiTanstackState({
         packageJson: packageJson2,
@@ -858,13 +1168,13 @@ BETTER_AUTH_URL=http://localhost:3000
         database: "prisma"
       });
     } else {
-      console.log(chalk5.green("\nCompleted installation successfully"));
-      console.log(chalk5.cyan("\nInstall Package:"));
-      console.log(chalk5.white(`\u2022 prisma ${database} schema
+      console.log(chalk7.green("\nCompleted installation successfully"));
+      console.log(chalk7.cyan("\nInstall Package:"));
+      console.log(chalk7.white(`\u2022 prisma ${database} schema
 \u2022 better-auth`));
-      console.log(chalk5.cyan("\nFiles created:"));
+      console.log(chalk7.cyan("\nFiles created:"));
       console.log(
-        chalk5.white(
+        chalk7.white(
           `\u2022 src/lib/auth.ts
 \u2022 src/lib/auth-client.ts
 \u2022 src/app/api/auth/[...all]/route.ts
@@ -874,110 +1184,115 @@ BETTER_AUTH_URL=http://localhost:3000
       );
     }
   } catch (err) {
-    console.log(chalk5.red("Prisma Run Tanstack State Error: ", err));
+    console.log(chalk7.red("Prisma Run Tanstack State Error: ", err));
   }
 };
 
 // script/drizzleRunTanstackStart.ts
-import chalk6 from "chalk";
-import path6 from "path";
-import fs6 from "fs";
-import { fileURLToPath as fileURLToPath6 } from "url";
-var drizzleRunTanstackStart = async ({
+import chalk10 from "chalk";
+import path10 from "path";
+import fs10 from "fs";
+
+// drizzle/drizzleTanstackSetup.ts
+import chalk8 from "chalk";
+import path8 from "path";
+import fs8 from "fs";
+import { fileURLToPath as fileURLToPath7 } from "url";
+var drizzleTanstackSetup = async ({
   authUi,
-  cmd
+  cmd,
+  projectDir
 }) => {
   try {
-    const projectDir = process.cwd();
-    const packageJsonPath = path6.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
+    const packageJsonPath = path8.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8"));
     if (!packageJson2.dependencies["better-auth"]) {
-      console.log(chalk6.cyan("\n\u2699\uFE0F  Initializing better auth...\n"));
+      console.log(chalk8.cyan("\n\u2699\uFE0F  Initializing better auth...\n"));
       packageManager("better-auth");
     }
     if (!packageJson2.dependencies["drizzle-orm"] && !packageJson2.dependencies["drizzle-orm"] && !packageJson2.dependencies["drizzle-kit"] && !packageJson2.devDependencies["drizzle-kit"]) {
-      console.log(chalk6.cyan("\n\u2699\uFE0F  Initializing drizzle...\n"));
+      console.log(chalk8.cyan("\n\u2699\uFE0F  Initializing drizzle...\n"));
       packageManager("drizzle-orm @neondatabase/serverless dotenv");
       packageManager("drizzle-kit", true);
     }
-    const __filename = fileURLToPath6(import.meta.url);
-    const __dirname = path6.dirname(__filename);
-    const envPath = path6.join(projectDir, ".env");
-    if (!fs6.existsSync(envPath)) {
-      fs6.writeFileSync(envPath, "DATABASE_URL=\n");
+    const __filename = fileURLToPath7(import.meta.url);
+    const __dirname = path8.dirname(__filename);
+    const envPath = path8.join(projectDir, ".env");
+    if (!fs8.existsSync(envPath)) {
+      fs8.writeFileSync(envPath, "DATABASE_URL=\n");
     }
     const secret = await GenerateSecret();
-    const envContent = fs6.readFileSync(envPath, "utf-8");
+    const envContent = fs8.readFileSync(envPath, "utf-8");
     if (!envContent.includes("BETTER_AUTH_SECRET")) {
-      fs6.appendFileSync(envPath, `
+      fs8.appendFileSync(envPath, `
 
 BETTER_AUTH_SECRET=${secret}`);
     }
     if (!envContent.includes("BETTER_AUTH_URL")) {
-      fs6.appendFileSync(envPath, `
+      fs8.appendFileSync(envPath, `
 BETTER_AUTH_URL=http://localhost:3000
 `);
     }
-    const srcPath = path6.join(projectDir, "src");
-    const libPath = path6.join(srcPath, "lib");
-    if (!fs6.existsSync(libPath)) {
-      fs6.mkdirSync(libPath, { recursive: true });
+    const srcPath = path8.join(projectDir, "src");
+    const libPath = path8.join(srcPath, "lib");
+    if (!fs8.existsSync(libPath)) {
+      fs8.mkdirSync(libPath, { recursive: true });
     }
-    const authTemplatePath = path6.resolve(
+    const authTemplatePath = path8.resolve(
       __dirname,
       "./template/TanstackStart/lib/auth-drizzle.ts"
     );
-    const authDestinationPath = path6.join(libPath, "auth.ts");
-    fs6.copyFileSync(authTemplatePath, authDestinationPath);
-    const authClientTemplatePath = path6.resolve(
+    const authDestinationPath = path8.join(libPath, "auth.ts");
+    fs8.copyFileSync(authTemplatePath, authDestinationPath);
+    const authClientTemplatePath = path8.resolve(
       __dirname,
       "./template/lib/auth-client.ts"
     );
-    const authClientDestinationPath = path6.join(libPath, "auth-client.ts");
-    fs6.copyFileSync(authClientTemplatePath, authClientDestinationPath);
-    const dbTemplatePath = path6.resolve(__dirname, "./template/db");
-    const dbDir = path6.join(projectDir, "db");
-    if (!fs6.existsSync(dbDir)) {
-      fs6.mkdirSync(dbDir, { recursive: true });
-    }
-    const dbDestinationPath = path6.join(dbDir, "drizzle.ts");
-    fs6.copyFileSync(`${dbTemplatePath}/drizzle.ts`, dbDestinationPath);
-    const schemaDestinationPath = path6.join(dbDir, "schema.ts");
-    fs6.copyFileSync(`${dbTemplatePath}/schema.ts`, schemaDestinationPath);
-    const drizzleConfigTemplatePath = path6.resolve(
+    const authClientDestinationPath = path8.join(libPath, "auth-client.ts");
+    fs8.copyFileSync(authClientTemplatePath, authClientDestinationPath);
+    const dbTemplatePath = path8.resolve(__dirname, "./template/db");
+    const dbDir = path8.join(projectDir, "db");
+    if (!fs8.existsSync(dbDir)) {
+      fs8.mkdirSync(dbDir, { recursive: true });
+    }
+    const dbDestinationPath = path8.join(dbDir, "drizzle.ts");
+    fs8.copyFileSync(`${dbTemplatePath}/drizzle.ts`, dbDestinationPath);
+    const schemaDestinationPath = path8.join(dbDir, "schema.ts");
+    fs8.copyFileSync(`${dbTemplatePath}/schema.ts`, schemaDestinationPath);
+    const drizzleConfigTemplatePath = path8.resolve(
       __dirname,
       "./template/config/drizzle.config.ts"
     );
-    const drizzleConfigDestinationPath = path6.join(
+    const drizzleConfigDestinationPath = path8.join(
       projectDir,
       "drizzle.config.ts"
     );
-    fs6.copyFileSync(drizzleConfigTemplatePath, drizzleConfigDestinationPath);
-    const middlewarePath = path6.join(srcPath, "middleware");
-    if (!fs6.existsSync(middlewarePath)) {
-      fs6.mkdirSync(middlewarePath, { recursive: true });
+    fs8.copyFileSync(drizzleConfigTemplatePath, drizzleConfigDestinationPath);
+    const middlewarePath = path8.join(srcPath, "middleware");
+    if (!fs8.existsSync(middlewarePath)) {
+      fs8.mkdirSync(middlewarePath, { recursive: true });
     }
-    const authMiddlewareTemplatePath = path6.resolve(
+    const authMiddlewareTemplatePath = path8.resolve(
       __dirname,
       `./template/TanstackStart/middleware/auth.ts`
     );
-    const authMiddlewareDestinationPath = path6.join(middlewarePath, "auth.ts");
-    fs6.copyFileSync(authMiddlewareTemplatePath, authMiddlewareDestinationPath);
-    const fileRouteTemplatePath = path6.resolve(
+    const authMiddlewareDestinationPath = path8.join(middlewarePath, "auth.ts");
+    fs8.copyFileSync(authMiddlewareTemplatePath, authMiddlewareDestinationPath);
+    const fileRouteTemplatePath = path8.resolve(
       __dirname,
       `./template/TanstackStart/routes/$.ts`
     );
-    const fileRouteDestinationPath = path6.join(
+    const fileRouteDestinationPath = path8.join(
       srcPath,
       "routes",
       "api",
       "auth"
     );
-    if (!fs6.existsSync(fileRouteDestinationPath)) {
-      fs6.mkdirSync(fileRouteDestinationPath, { recursive: true });
+    if (!fs8.existsSync(fileRouteDestinationPath)) {
+      fs8.mkdirSync(fileRouteDestinationPath, { recursive: true });
     }
-    const apiDestinationPath = path6.join(fileRouteDestinationPath, "$.ts");
-    fs6.copyFileSync(fileRouteTemplatePath, apiDestinationPath);
+    const apiDestinationPath = path8.join(fileRouteDestinationPath, "$.ts");
+    fs8.copyFileSync(fileRouteTemplatePath, apiDestinationPath);
     if (authUi) {
       await authUiTanstackState({
         packageJson: packageJson2,
@@ -985,13 +1300,13 @@ BETTER_AUTH_URL=http://localhost:3000
         database: "drizzle"
       });
     } else {
-      console.log(chalk6.green("\nCompleted installation successfully"));
-      console.log(chalk6.cyan("\nInstall Package:"));
-      console.log(chalk6.white(`\u2022 drizzle schema
+      console.log(chalk8.green("\nCompleted installation successfully"));
+      console.log(chalk8.cyan("\nInstall Package:"));
+      console.log(chalk8.white(`\u2022 drizzle schema
 \u2022 better-auth`));
-      console.log(chalk6.cyan("\nFiles created:"));
+      console.log(chalk8.cyan("\nFiles created:"));
       console.log(
-        chalk6.white(
+        chalk8.white(
           `\u2022 src/lib/auth.ts
 \u2022 src/lib/auth-client.ts
 \u2022 src/app/api/auth/[...all]/route.ts
@@ -1000,73 +1315,293 @@ BETTER_AUTH_URL=http://localhost:3000
         )
       );
     }
-  } catch (err) {
-    console.error(chalk6.red("Drizzle setup failed:"), err);
-  }
-};
-
-// utils/framework.ts
-import path7 from "path";
-import fs7 from "fs";
-var getFramework = async () => {
-  const projectDir = process.cwd();
-  if (!fs7.existsSync(path7.join(projectDir, "package.json"))) {
-    return {
-      framework: null,
-      error: "No framework detected"
-    };
-  }
-  const packageJson2 = JSON.parse(
-    fs7.readFileSync(path7.join(projectDir, "package.json"), "utf-8")
-  );
-  const hasNext = packageJson2?.dependencies?.["next"] || packageJson2?.devDependencies?.["next"];
-  if (hasNext) {
-    return {
-      framework: "Next js",
-      error: null
-    };
-  }
-  const hasTanstackState = packageJson2?.devDependencies?.["@tanstack/devtools-vite"] || packageJson2?.devDependencies?.["@tanstack/eslint-config"] || packageJson2?.devDependencies?.["@tanstack/react-start"];
-  if (hasTanstackState) {
-    return {
-      framework: "tanstack start",
-      error: null
-    };
+  } catch (error) {
+    console.log(chalk8.red("Failed to setup drizzle ", error));
   }
-  return {
-    framework: null,
-    error: "No framework supported authverse"
-  };
 };
 
-// cli/init.ts
-import chalk7 from "chalk";
-var initAnswer = async () => {
-  const { framework, error } = await getFramework();
-  if (error) {
-    console.log(chalk7.red(error));
-    return;
-  }
-  console.log(`\u2714 Detected framework: ${framework}`);
-  const answers = await inquirer3.prompt([
-    {
-      type: "list",
-      name: "orm",
-      message: "Choose Your ORM:",
-      choices: ["Prisma", "Drizzle"]
-    },
-    {
-      type: "list",
-      name: "database",
-      message: "Select Database:",
-      choices: ["Postgresql", "Mongodb", "Mysql"],
-      when: (ans) => ans.orm === "Prisma"
-    },
-    {
-      type: "confirm",
-      name: "authUi",
-      message: "Do you want to include auth UI design?",
-      default: true
+// drizzle/drizzleTanstackChecker.ts
+import chalk9 from "chalk";
+import path9 from "path";
+import fs9 from "fs";
+import { fileURLToPath as fileURLToPath8 } from "url";
+var drizzleTanstackChecker = async ({
+  authUi,
+  cmd,
+  projectDir
+}) => {
+  try {
+    const drizzleConfigPath = path9.join(projectDir, "drizzle.config.ts");
+    if (!fs9.existsSync(drizzleConfigPath)) {
+      return await drizzleTanstackSetup({ authUi, cmd, projectDir });
+    }
+    const drizzleConfigContent = fs9.readFileSync(drizzleConfigPath, "utf-8");
+    const schemaMatch = drizzleConfigContent.match(/schema:\s*["'`](.*?)["'`]/);
+    const schemaPath = schemaMatch ? schemaMatch[1] : null;
+    if (!schemaPath || schemaPath === "") {
+      return await drizzleTanstackSetup({ authUi, cmd, projectDir });
+    }
+    const __filename = fileURLToPath8(import.meta.url);
+    const __dirname = path9.dirname(__filename);
+    const dbTemplatePath = path9.resolve(__dirname, "./template/db/schema.ts");
+    const schemaFilePath = path9.join(projectDir, schemaPath);
+    if (!fs9.existsSync(schemaFilePath)) {
+      const dbFolder = path9.dirname(schemaFilePath);
+      if (!fs9.existsSync(dbFolder)) {
+        fs9.mkdirSync(dbFolder, { recursive: true });
+      }
+      fs9.copyFileSync(dbTemplatePath, schemaFilePath);
+    } else {
+      let schemaFileContent = fs9.readFileSync(schemaFilePath, "utf-8");
+      const dbTemplateContent = fs9.readFileSync(dbTemplatePath, "utf-8");
+      const requiredTables = ["user", "session", "account", "verification"];
+      let needsUpdate = false;
+      let updatedSchemaContent = schemaFileContent;
+      for (const table of requiredTables) {
+        const existingTable = extractTableDefinition(
+          updatedSchemaContent,
+          table
+        );
+        const templateTable = extractTableDefinition(dbTemplateContent, table);
+        if (!existingTable && templateTable) {
+          const schemaExportIndex = updatedSchemaContent.indexOf(
+            "export const schema ="
+          );
+          if (schemaExportIndex !== -1) {
+            updatedSchemaContent = updatedSchemaContent.slice(0, schemaExportIndex) + templateTable + "\n\n" + updatedSchemaContent.slice(schemaExportIndex);
+          } else {
+            updatedSchemaContent += "\n\n" + templateTable;
+          }
+          needsUpdate = true;
+        } else if (existingTable && templateTable) {
+          const existingColumns = extractColumnNames(existingTable);
+          const templateColumns = extractColumnNames(templateTable);
+          const missingColumns = templateColumns.filter(
+            (col) => !existingColumns.includes(col)
+          );
+          if (missingColumns.length > 0) {
+            const updatedTable = addMissingColumnsToTable(
+              existingTable,
+              templateTable
+            );
+            updatedSchemaContent = updatedSchemaContent.replace(
+              existingTable,
+              updatedTable
+            );
+            needsUpdate = true;
+          }
+        }
+      }
+      if (needsUpdate) {
+        const schemaExportRegex = /export const schema = \{([\s\S]*?)\};/;
+        const schemaMatch2 = updatedSchemaContent.match(schemaExportRegex);
+        if (schemaMatch2) {
+          let currentSchemaContent = schemaMatch2[1];
+          for (const table of requiredTables) {
+            if (!currentSchemaContent.includes(`${table},`)) {
+              const lines = currentSchemaContent.split("\n");
+              const lastNonEmptyLine = lines.length - 1;
+              if (lines[lastNonEmptyLine].trim() === "}") {
+                lines[lastNonEmptyLine] = `  ${table},
+${lines[lastNonEmptyLine]}`;
+              } else {
+                lines.push(`  ${table},`);
+              }
+              currentSchemaContent = lines.join("\n");
+            }
+          }
+          updatedSchemaContent = updatedSchemaContent.replace(
+            schemaExportRegex,
+            `export const schema = {${currentSchemaContent}};`
+          );
+        }
+        fs9.writeFileSync(schemaFilePath, updatedSchemaContent);
+      }
+    }
+    const packageJsonPath = path9.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(fs9.readFileSync(packageJsonPath, "utf-8"));
+    if (!packageJson2.dependencies["better-auth"]) {
+      console.log(chalk9.cyan("\n\u2699\uFE0F  Initializing better auth...\n"));
+      packageManager("better-auth");
+    }
+    const drizzleDeps = [
+      "drizzle-orm",
+      "@neondatabase/serverless",
+      "dotenv",
+      "drizzle-kit"
+    ];
+    const missingDrizzleDeps = drizzleDeps.filter((dep) => {
+      return !packageJson2.dependencies?.[dep] && !packageJson2.devDependencies?.[dep];
+    });
+    if (missingDrizzleDeps.length > 0) {
+      console.log(chalk9.cyan("\n\u2699\uFE0F  Initializing drizzle...\n"));
+      packageManager(missingDrizzleDeps.join(" "));
+    }
+    const envPath = path9.join(projectDir, ".env");
+    if (!fs9.existsSync(envPath)) {
+      fs9.writeFileSync(envPath, "DATABASE_URL=\n");
+    }
+    const secret = await GenerateSecret();
+    const envContent = fs9.readFileSync(envPath, "utf-8");
+    if (!envContent.includes("BETTER_AUTH_SECRET")) {
+      fs9.appendFileSync(envPath, `
+
+BETTER_AUTH_SECRET=${secret}`);
+    }
+    if (!envContent.includes("BETTER_AUTH_URL")) {
+      fs9.appendFileSync(envPath, `
+BETTER_AUTH_URL=http://localhost:3000
+`);
+    }
+    const srcPath = path9.join(projectDir, "src");
+    const libPath = path9.join(srcPath, "lib");
+    if (!fs9.existsSync(libPath)) {
+      fs9.mkdirSync(libPath, { recursive: true });
+    }
+    const authTemplatePath = path9.resolve(
+      __dirname,
+      "./template/TanstackStart/lib/auth-drizzle.ts"
+    );
+    const authDestinationPath = path9.join(libPath, "auth.ts");
+    fs9.copyFileSync(authTemplatePath, authDestinationPath);
+    const authClientTemplatePath = path9.resolve(
+      __dirname,
+      "./template/lib/auth-client.ts"
+    );
+    const authClientDestinationPath = path9.join(libPath, "auth-client.ts");
+    fs9.copyFileSync(authClientTemplatePath, authClientDestinationPath);
+    const middlewarePath = path9.join(srcPath, "middleware");
+    if (!fs9.existsSync(middlewarePath)) {
+      fs9.mkdirSync(middlewarePath, { recursive: true });
+    }
+    const authMiddlewareTemplatePath = path9.resolve(
+      __dirname,
+      `./template/TanstackStart/middleware/auth.ts`
+    );
+    const authMiddlewareDestinationPath = path9.join(middlewarePath, "auth.ts");
+    fs9.copyFileSync(authMiddlewareTemplatePath, authMiddlewareDestinationPath);
+    const fileRouteTemplatePath = path9.resolve(
+      __dirname,
+      `./template/TanstackStart/routes/$.ts`
+    );
+    const fileRouteDestinationPath = path9.join(
+      srcPath,
+      "routes",
+      "api",
+      "auth"
+    );
+    if (!fs9.existsSync(fileRouteDestinationPath)) {
+      fs9.mkdirSync(fileRouteDestinationPath, { recursive: true });
+    }
+    const apiDestinationPath = path9.join(fileRouteDestinationPath, "$.ts");
+    fs9.copyFileSync(fileRouteTemplatePath, apiDestinationPath);
+    if (authUi) {
+      await authUiTanstackState({
+        packageJson: packageJson2,
+        cmd,
+        database: "drizzle"
+      });
+    } else {
+      console.log(chalk9.green("\nCompleted installation successfully"));
+      console.log(chalk9.cyan("\nInstall Package:"));
+      console.log(chalk9.white(`\u2022 drizzle schema
+\u2022 better-auth`));
+      console.log(chalk9.cyan("\nFiles created:"));
+      console.log(
+        chalk9.white(
+          `\u2022 src/lib/auth.ts
+\u2022 src/lib/auth-client.ts
+\u2022 src/app/api/auth/[...all]/route.ts
+\u2022 src/proxy.ts
+`
+        )
+      );
+    }
+  } catch (error) {
+    console.log(chalk9.red("Failed to setup drizzle ", error));
+  }
+};
+
+// script/drizzleRunTanstackStart.ts
+var drizzleRunTanstackStart = async ({
+  authUi,
+  cmd
+}) => {
+  try {
+    const projectDir = process.cwd();
+    const drizzleConfigPath = path10.join(projectDir, "drizzle.config.ts");
+    if (fs10.existsSync(drizzleConfigPath)) {
+      await drizzleTanstackChecker({ authUi, cmd, projectDir });
+    } else {
+      await drizzleTanstackSetup({ authUi, cmd, projectDir });
+    }
+  } catch (err) {
+    console.error(chalk10.red("Drizzle setup failed:"), err);
+  }
+};
+
+// utils/framework.ts
+import path11 from "path";
+import fs11 from "fs";
+var getFramework = async () => {
+  const projectDir = process.cwd();
+  if (!fs11.existsSync(path11.join(projectDir, "package.json"))) {
+    return {
+      framework: null,
+      error: "No framework detected"
+    };
+  }
+  const packageJson2 = JSON.parse(
+    fs11.readFileSync(path11.join(projectDir, "package.json"), "utf-8")
+  );
+  const hasNext = packageJson2?.dependencies?.["next"] || packageJson2?.devDependencies?.["next"];
+  if (hasNext) {
+    return {
+      framework: "Next js",
+      error: null
+    };
+  }
+  const hasTanstackState = packageJson2?.devDependencies?.["@tanstack/devtools-vite"] || packageJson2?.devDependencies?.["@tanstack/eslint-config"] || packageJson2?.devDependencies?.["@tanstack/react-start"];
+  if (hasTanstackState) {
+    return {
+      framework: "tanstack start",
+      error: null
+    };
+  }
+  return {
+    framework: null,
+    error: "No framework supported authverse"
+  };
+};
+
+// cli/init.ts
+import chalk11 from "chalk";
+var initAnswer = async () => {
+  const { framework, error } = await getFramework();
+  if (error) {
+    console.log(chalk11.red(error));
+    return;
+  }
+  console.log(`\u2714 Detected framework: ${framework}`);
+  const answers = await inquirer4.prompt([
+    {
+      type: "select",
+      name: "orm",
+      message: "Choose Your ORM:",
+      choices: ["Prisma", "Drizzle"]
+    },
+    {
+      type: "select",
+      name: "database",
+      message: "Select Database:",
+      choices: ["Postgresql", "Mongodb", "Mysql"],
+      when: (ans) => ans.orm === "Prisma"
+    },
+    {
+      type: "confirm",
+      name: "authUi",
+      message: "Do you want to include auth UI design?",
+      default: true
     }
   ]);
   if (framework === "Next js" && answers.orm === "Prisma") {
@@ -1101,33 +1636,33 @@ var initAnswer = async () => {
 import { readFileSync } from "fs";
 
 // cli/oauth.ts
-import chalk20 from "chalk";
+import chalk24 from "chalk";
 
 // oauth/googleNext.ts
-import chalk8 from "chalk";
-import fs8 from "fs";
-import path8 from "path";
-import { fileURLToPath as fileURLToPath7 } from "url";
+import chalk12 from "chalk";
+import fs12 from "fs";
+import path12 from "path";
+import { fileURLToPath as fileURLToPath9 } from "url";
 var googleNext = async () => {
   try {
-    const __filename = fileURLToPath7(import.meta.url);
-    const __dirname = path8.dirname(__filename);
+    const __filename = fileURLToPath9(import.meta.url);
+    const __dirname = path12.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = path8.join(projectDir, "src");
-    const folder = fs8.existsSync(srcPath) ? "src" : "";
-    const authFilePath = path8.join(projectDir, folder, "lib", "auth.ts");
-    if (!fs8.existsSync(authFilePath)) {
-      console.log(chalk8.red("No Configured Better Auth file found"));
-      console.log(chalk8.cyan("Run authverse init to initialize better auth"));
+    const srcPath = path12.join(projectDir, "src");
+    const folder = fs12.existsSync(srcPath) ? "src" : "";
+    const authFilePath = path12.join(projectDir, folder, "lib", "auth.ts");
+    if (!fs12.existsSync(authFilePath)) {
+      console.log(chalk12.red("No Configured Better Auth file found"));
+      console.log(chalk12.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = fs8.readFileSync(authFilePath, "utf8");
+    let content = fs12.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk8.red("betterAuth({}) block not found"));
+      console.log(chalk12.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("google:")) {
-      console.log(chalk8.yellow("Google provider already exists"));
+      console.log(chalk12.yellow("Google provider already exists"));
       return;
     }
     const googleProviderEntry = `
@@ -1150,7 +1685,7 @@ var googleNext = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk8.red("Failed to parse socialProviders block"));
+        console.log(chalk12.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + googleProviderEntry + "\n  " + content.slice(insertPos);
@@ -1158,7 +1693,7 @@ var googleNext = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk8.red(
+          chalk12.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1174,12 +1709,12 @@ ${googleProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    fs8.writeFileSync(authFilePath, content, "utf8");
-    const envPath = path8.join(projectDir, ".env");
-    if (fs8.existsSync(envPath)) {
-      const envContent = fs8.readFileSync(envPath, "utf8");
+    fs12.writeFileSync(authFilePath, content, "utf8");
+    const envPath = path12.join(projectDir, ".env");
+    if (fs12.existsSync(envPath)) {
+      const envContent = fs12.readFileSync(envPath, "utf8");
       if (!envContent.includes("GOOGLE_CLIENT_ID")) {
-        fs8.appendFileSync(
+        fs12.appendFileSync(
           envPath,
           `
 
@@ -1190,60 +1725,60 @@ GOOGLE_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = path8.resolve(
+    const componentTemplate = path12.resolve(
       __dirname,
       "./template/components/GoogleOAuthButton.tsx"
     );
-    const componentsDir = path8.join(
+    const componentsDir = path12.join(
       projectDir,
       folder,
       "components",
       "authverse"
     );
-    if (!fs8.existsSync(componentsDir)) {
-      fs8.mkdirSync(componentsDir, { recursive: true });
+    if (!fs12.existsSync(componentsDir)) {
+      fs12.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = path8.join(componentsDir, "GoogleOAuthButton.tsx");
-    if (fs8.existsSync(componentTemplate)) {
-      fs8.copyFileSync(componentTemplate, componentDest);
+    const componentDest = path12.join(componentsDir, "GoogleOAuthButton.tsx");
+    if (fs12.existsSync(componentTemplate)) {
+      fs12.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk8.green("Google provider added & merged successfully\n"));
+    console.log(chalk12.green("Google provider added & merged successfully\n"));
     console.log(
-      chalk8.white(
+      chalk12.white(
         `${CreateFolder({ srcFolder: folder, destFolder: "components/authverse/GoogleOAuthButton.tsx" })}
 `
       )
     );
   } catch (error) {
-    console.log(chalk8.red("googleRun error:"), error);
+    console.log(chalk12.red("googleRun error:"), error);
   }
 };
 
 // oauth/githubNext.ts
-import chalk9 from "chalk";
-import fs9 from "fs";
-import path9 from "path";
-import { fileURLToPath as fileURLToPath8 } from "url";
+import chalk13 from "chalk";
+import fs13 from "fs";
+import path13 from "path";
+import { fileURLToPath as fileURLToPath10 } from "url";
 var githubNext = async () => {
   try {
-    const __filename = fileURLToPath8(import.meta.url);
-    const __dirname = path9.dirname(__filename);
+    const __filename = fileURLToPath10(import.meta.url);
+    const __dirname = path13.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = path9.join(projectDir, "src");
-    const folder = fs9.existsSync(srcPath) ? "src" : "";
-    const authFilePath = path9.join(projectDir, folder, "lib", "auth.ts");
-    if (!fs9.existsSync(authFilePath)) {
-      console.log(chalk9.red("No Configured Better Auth file found"));
-      console.log(chalk9.cyan("Run authverse init to initialize better auth"));
+    const srcPath = path13.join(projectDir, "src");
+    const folder = fs13.existsSync(srcPath) ? "src" : "";
+    const authFilePath = path13.join(projectDir, folder, "lib", "auth.ts");
+    if (!fs13.existsSync(authFilePath)) {
+      console.log(chalk13.red("No Configured Better Auth file found"));
+      console.log(chalk13.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = fs9.readFileSync(authFilePath, "utf8");
+    let content = fs13.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk9.red("betterAuth({}) block not found"));
+      console.log(chalk13.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("github:")) {
-      console.log(chalk9.yellow("GitHub provider already exists"));
+      console.log(chalk13.yellow("GitHub provider already exists"));
       return;
     }
     const githubProviderEntry = `
@@ -1266,7 +1801,7 @@ var githubNext = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk9.red("Failed to parse socialProviders block"));
+        console.log(chalk13.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + githubProviderEntry + "\n  " + content.slice(insertPos);
@@ -1274,7 +1809,7 @@ var githubNext = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk9.red(
+          chalk13.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1290,12 +1825,12 @@ ${githubProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    fs9.writeFileSync(authFilePath, content, "utf8");
-    const envPath = path9.join(projectDir, ".env");
-    if (fs9.existsSync(envPath)) {
-      const envContent = fs9.readFileSync(envPath, "utf8");
+    fs13.writeFileSync(authFilePath, content, "utf8");
+    const envPath = path13.join(projectDir, ".env");
+    if (fs13.existsSync(envPath)) {
+      const envContent = fs13.readFileSync(envPath, "utf8");
       if (!envContent.includes("GITHUB_CLIENT_ID")) {
-        fs9.appendFileSync(
+        fs13.appendFileSync(
           envPath,
           `
 
@@ -1306,59 +1841,59 @@ GITHUB_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = path9.resolve(
+    const componentTemplate = path13.resolve(
       __dirname,
       "./template/components/GithubOAuthButton.tsx"
     );
-    const componentsDir = path9.join(
+    const componentsDir = path13.join(
       projectDir,
       folder,
       "components",
       "authverse"
     );
-    if (!fs9.existsSync(componentsDir)) {
-      fs9.mkdirSync(componentsDir, { recursive: true });
+    if (!fs13.existsSync(componentsDir)) {
+      fs13.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = path9.join(componentsDir, "GithubOAuthButton.tsx");
-    if (fs9.existsSync(componentTemplate)) {
-      fs9.copyFileSync(componentTemplate, componentDest);
+    const componentDest = path13.join(componentsDir, "GithubOAuthButton.tsx");
+    if (fs13.existsSync(componentTemplate)) {
+      fs13.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk9.green("GitHub provider added & merged successfully\n"));
+    console.log(chalk13.green("GitHub provider added & merged successfully\n"));
     console.log(
-      chalk9.white(
+      chalk13.white(
         `${CreateFolder({ srcFolder: folder, destFolder: "components/authverse/GithubOAuthButton.tsx" })}
 `
       )
     );
   } catch (error) {
-    console.log(chalk9.red("githubRun error:"), error);
+    console.log(chalk13.red("githubRun error:"), error);
   }
 };
 
 // oauth/googleTanstackStart.ts
-import chalk10 from "chalk";
-import fs10 from "fs";
-import path10 from "path";
-import { fileURLToPath as fileURLToPath9 } from "url";
+import chalk14 from "chalk";
+import fs14 from "fs";
+import path14 from "path";
+import { fileURLToPath as fileURLToPath11 } from "url";
 var googleTanstackStart = async () => {
   try {
-    const __filename = fileURLToPath9(import.meta.url);
-    const __dirname = path10.dirname(__filename);
+    const __filename = fileURLToPath11(import.meta.url);
+    const __dirname = path14.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = path10.join(projectDir, "src");
-    const authFilePath = path10.join(srcPath, "lib", "auth.ts");
-    if (!fs10.existsSync(authFilePath)) {
-      console.log(chalk10.red("No Configured Better Auth file found"));
-      console.log(chalk10.cyan("Run authverse init to initialize better auth"));
+    const srcPath = path14.join(projectDir, "src");
+    const authFilePath = path14.join(srcPath, "lib", "auth.ts");
+    if (!fs14.existsSync(authFilePath)) {
+      console.log(chalk14.red("No Configured Better Auth file found"));
+      console.log(chalk14.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = fs10.readFileSync(authFilePath, "utf8");
+    let content = fs14.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk10.red("betterAuth({}) block not found"));
+      console.log(chalk14.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("google:")) {
-      console.log(chalk10.yellow("Google provider already exists"));
+      console.log(chalk14.yellow("Google provider already exists"));
       return;
     }
     const googleProviderEntry = `
@@ -1381,7 +1916,7 @@ var googleTanstackStart = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk10.red("Failed to parse socialProviders block"));
+        console.log(chalk14.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + googleProviderEntry + "\n  " + content.slice(insertPos);
@@ -1389,7 +1924,7 @@ var googleTanstackStart = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk10.red(
+          chalk14.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1405,12 +1940,12 @@ ${googleProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    fs10.writeFileSync(authFilePath, content, "utf8");
-    const envPath = path10.join(projectDir, ".env");
-    if (fs10.existsSync(envPath)) {
-      const envContent = fs10.readFileSync(envPath, "utf8");
+    fs14.writeFileSync(authFilePath, content, "utf8");
+    const envPath = path14.join(projectDir, ".env");
+    if (fs14.existsSync(envPath)) {
+      const envContent = fs14.readFileSync(envPath, "utf8");
       if (!envContent.includes("GOOGLE_CLIENT_ID")) {
-        fs10.appendFileSync(
+        fs14.appendFileSync(
           envPath,
           `
 
@@ -1421,51 +1956,51 @@ GOOGLE_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = path10.resolve(
+    const componentTemplate = path14.resolve(
       __dirname,
       "./template/TanstackStart/components/GoogleOAuthButton.tsx"
     );
-    const componentsDir = path10.join(srcPath, "components", "authverse");
-    if (!fs10.existsSync(componentsDir)) {
-      fs10.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = path14.join(srcPath, "components", "authverse");
+    if (!fs14.existsSync(componentsDir)) {
+      fs14.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = path10.join(componentsDir, "GoogleOAuthButton.tsx");
-    if (fs10.existsSync(componentTemplate)) {
-      fs10.copyFileSync(componentTemplate, componentDest);
+    const componentDest = path14.join(componentsDir, "GoogleOAuthButton.tsx");
+    if (fs14.existsSync(componentTemplate)) {
+      fs14.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk10.green("Google provider added & merged successfully\n"));
+    console.log(chalk14.green("Google provider added & merged successfully\n"));
     console.log(
-      chalk10.white("\u2022 src/components/authverse/GoogleOAuthButton.tsx")
+      chalk14.white("\u2022 src/components/authverse/GoogleOAuthButton.tsx")
     );
   } catch (error) {
-    console.log(chalk10.red("googleRunTanstackState error:"), error);
+    console.log(chalk14.red("googleRunTanstackState error:"), error);
   }
 };
 
 // oauth/githubTanstackStart.ts
-import chalk11 from "chalk";
-import fs11 from "fs";
-import path11 from "path";
-import { fileURLToPath as fileURLToPath10 } from "url";
+import chalk15 from "chalk";
+import fs15 from "fs";
+import path15 from "path";
+import { fileURLToPath as fileURLToPath12 } from "url";
 var githubTanstackStart = async () => {
   try {
-    const __filename = fileURLToPath10(import.meta.url);
-    const __dirname = path11.dirname(__filename);
+    const __filename = fileURLToPath12(import.meta.url);
+    const __dirname = path15.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = path11.join(projectDir, "src");
-    const authFilePath = path11.join(srcPath, "lib", "auth.ts");
-    if (!fs11.existsSync(authFilePath)) {
-      console.log(chalk11.red("No Configured Better Auth file found"));
-      console.log(chalk11.cyan("Run authverse init to initialize better auth"));
+    const srcPath = path15.join(projectDir, "src");
+    const authFilePath = path15.join(srcPath, "lib", "auth.ts");
+    if (!fs15.existsSync(authFilePath)) {
+      console.log(chalk15.red("No Configured Better Auth file found"));
+      console.log(chalk15.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = fs11.readFileSync(authFilePath, "utf8");
+    let content = fs15.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk11.red("betterAuth({}) block not found"));
+      console.log(chalk15.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("github:")) {
-      console.log(chalk11.yellow("Github provider already exists"));
+      console.log(chalk15.yellow("Github provider already exists"));
       return;
     }
     const githubProviderEntry = `
@@ -1488,7 +2023,7 @@ var githubTanstackStart = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk11.red("Failed to parse socialProviders block"));
+        console.log(chalk15.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + githubProviderEntry + "\n  " + content.slice(insertPos);
@@ -1496,7 +2031,7 @@ var githubTanstackStart = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk11.red(
+          chalk15.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1512,12 +2047,12 @@ ${githubProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    fs11.writeFileSync(authFilePath, content, "utf8");
-    const envPath = path11.join(projectDir, ".env");
-    if (fs11.existsSync(envPath)) {
-      const envContent = fs11.readFileSync(envPath, "utf8");
+    fs15.writeFileSync(authFilePath, content, "utf8");
+    const envPath = path15.join(projectDir, ".env");
+    if (fs15.existsSync(envPath)) {
+      const envContent = fs15.readFileSync(envPath, "utf8");
       if (!envContent.includes("GITHUB_CLIENT_ID")) {
-        fs11.appendFileSync(
+        fs15.appendFileSync(
           envPath,
           `
 
@@ -1528,52 +2063,52 @@ GITHUB_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = path11.resolve(
+    const componentTemplate = path15.resolve(
       __dirname,
       "./template/TanstackStart/components/GithubOAuthButton.tsx"
     );
-    const componentsDir = path11.join(srcPath, "components", "authverse");
-    if (!fs11.existsSync(componentsDir)) {
-      fs11.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = path15.join(srcPath, "components", "authverse");
+    if (!fs15.existsSync(componentsDir)) {
+      fs15.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = path11.join(componentsDir, "GithubOAuthButton.tsx");
-    if (fs11.existsSync(componentTemplate)) {
-      fs11.copyFileSync(componentTemplate, componentDest);
+    const componentDest = path15.join(componentsDir, "GithubOAuthButton.tsx");
+    if (fs15.existsSync(componentTemplate)) {
+      fs15.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk11.green("Github provider added & merged successfully\n"));
+    console.log(chalk15.green("Github provider added & merged successfully\n"));
     console.log(
-      chalk11.white("\u2022 src/components/authverse/GithubOAuthButton.tsx")
+      chalk15.white("\u2022 src/components/authverse/GithubOAuthButton.tsx")
     );
   } catch (error) {
-    console.log(chalk11.red("githubRunTanstackState error:"), error);
+    console.log(chalk15.red("githubRunTanstackState error:"), error);
   }
 };
 
 // oauth/facebookNext.ts
-import chalk12 from "chalk";
-import fs12 from "fs";
-import path12 from "path";
-import { fileURLToPath as fileURLToPath11 } from "url";
+import chalk16 from "chalk";
+import fs16 from "fs";
+import path16 from "path";
+import { fileURLToPath as fileURLToPath13 } from "url";
 var facebookNext = async () => {
   try {
-    const __filename = fileURLToPath11(import.meta.url);
-    const __dirname = path12.dirname(__filename);
+    const __filename = fileURLToPath13(import.meta.url);
+    const __dirname = path16.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = path12.join(projectDir, "src");
-    const folder = fs12.existsSync(srcPath) ? "src" : "";
-    const authFilePath = path12.join(projectDir, folder, "lib", "auth.ts");
-    if (!fs12.existsSync(authFilePath)) {
-      console.log(chalk12.red("No Configured Better Auth file found"));
-      console.log(chalk12.cyan("Run authverse init to initialize better auth"));
+    const srcPath = path16.join(projectDir, "src");
+    const folder = fs16.existsSync(srcPath) ? "src" : "";
+    const authFilePath = path16.join(projectDir, folder, "lib", "auth.ts");
+    if (!fs16.existsSync(authFilePath)) {
+      console.log(chalk16.red("No Configured Better Auth file found"));
+      console.log(chalk16.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = fs12.readFileSync(authFilePath, "utf8");
+    let content = fs16.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk12.red("betterAuth({}) block not found"));
+      console.log(chalk16.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("facebook:")) {
-      console.log(chalk12.yellow("Facebook provider already exists"));
+      console.log(chalk16.yellow("Facebook provider already exists"));
       return;
     }
     const facebookProviderEntry = `
@@ -1596,7 +2131,7 @@ var facebookNext = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk12.red("Failed to parse socialProviders block"));
+        console.log(chalk16.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + facebookProviderEntry + "\n  " + content.slice(insertPos);
@@ -1604,7 +2139,7 @@ var facebookNext = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk12.red(
+          chalk16.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1620,12 +2155,12 @@ ${facebookProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    fs12.writeFileSync(authFilePath, content, "utf8");
-    const envPath = path12.join(projectDir, ".env");
-    if (fs12.existsSync(envPath)) {
-      const envContent = fs12.readFileSync(envPath, "utf8");
+    fs16.writeFileSync(authFilePath, content, "utf8");
+    const envPath = path16.join(projectDir, ".env");
+    if (fs16.existsSync(envPath)) {
+      const envContent = fs16.readFileSync(envPath, "utf8");
       if (!envContent.includes("FACEBOOK_CLIENT_ID")) {
-        fs12.appendFileSync(
+        fs16.appendFileSync(
           envPath,
           `
 
@@ -1636,59 +2171,59 @@ FACEBOOK_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = path12.resolve(
+    const componentTemplate = path16.resolve(
       __dirname,
       "./template/components/FacebookOAuthButton.tsx"
     );
-    const componentsDir = path12.join(
+    const componentsDir = path16.join(
       projectDir,
       folder,
       "components",
       "authverse"
     );
-    if (!fs12.existsSync(componentsDir)) {
-      fs12.mkdirSync(componentsDir, { recursive: true });
+    if (!fs16.existsSync(componentsDir)) {
+      fs16.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = path12.join(componentsDir, "FacebookOAuthButton.tsx");
-    if (fs12.existsSync(componentTemplate)) {
-      fs12.copyFileSync(componentTemplate, componentDest);
+    const componentDest = path16.join(componentsDir, "FacebookOAuthButton.tsx");
+    if (fs16.existsSync(componentTemplate)) {
+      fs16.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk12.green("Facebook provider added & merged successfully\n"));
+    console.log(chalk16.green("Facebook provider added & merged successfully\n"));
     console.log(
-      chalk12.white(
+      chalk16.white(
         `${CreateFolder({ srcFolder: folder, destFolder: "components/authverse/FacebookOAuthButton.tsx" })}
 `
       )
     );
   } catch (error) {
-    console.log(chalk12.red("facebookRun error:"), error);
+    console.log(chalk16.red("facebookRun error:"), error);
   }
 };
 
 // oauth/facebookTanstackStart.ts
-import chalk13 from "chalk";
-import fs13 from "fs";
-import path13 from "path";
-import { fileURLToPath as fileURLToPath12 } from "url";
+import chalk17 from "chalk";
+import fs17 from "fs";
+import path17 from "path";
+import { fileURLToPath as fileURLToPath14 } from "url";
 var facebookTanstackStart = async () => {
   try {
-    const __filename = fileURLToPath12(import.meta.url);
-    const __dirname = path13.dirname(__filename);
+    const __filename = fileURLToPath14(import.meta.url);
+    const __dirname = path17.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = path13.join(projectDir, "src");
-    const authFilePath = path13.join(srcPath, "lib", "auth.ts");
-    if (!fs13.existsSync(authFilePath)) {
-      console.log(chalk13.red("No Configured Better Auth file found"));
-      console.log(chalk13.cyan("Run authverse init to initialize better auth"));
+    const srcPath = path17.join(projectDir, "src");
+    const authFilePath = path17.join(srcPath, "lib", "auth.ts");
+    if (!fs17.existsSync(authFilePath)) {
+      console.log(chalk17.red("No Configured Better Auth file found"));
+      console.log(chalk17.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = fs13.readFileSync(authFilePath, "utf8");
+    let content = fs17.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk13.red("betterAuth({}) block not found"));
+      console.log(chalk17.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("facebook:")) {
-      console.log(chalk13.yellow("Facebook provider already exists"));
+      console.log(chalk17.yellow("Facebook provider already exists"));
       return;
     }
     const facebookProviderEntry = `
@@ -1711,7 +2246,7 @@ var facebookTanstackStart = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk13.red("Failed to parse socialProviders block"));
+        console.log(chalk17.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + facebookProviderEntry + "\n  " + content.slice(insertPos);
@@ -1719,7 +2254,7 @@ var facebookTanstackStart = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk13.red(
+          chalk17.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1735,12 +2270,12 @@ ${facebookProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    fs13.writeFileSync(authFilePath, content, "utf8");
-    const envPath = path13.join(projectDir, ".env");
-    if (fs13.existsSync(envPath)) {
-      const envContent = fs13.readFileSync(envPath, "utf8");
+    fs17.writeFileSync(authFilePath, content, "utf8");
+    const envPath = path17.join(projectDir, ".env");
+    if (fs17.existsSync(envPath)) {
+      const envContent = fs17.readFileSync(envPath, "utf8");
       if (!envContent.includes("FACEBOOK_CLIENT_ID")) {
-        fs13.appendFileSync(
+        fs17.appendFileSync(
           envPath,
           `
 
@@ -1751,52 +2286,52 @@ FACEBOOK_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = path13.resolve(
+    const componentTemplate = path17.resolve(
       __dirname,
       "./template/TanstackStart/components/FacebookOAuthButton.tsx"
     );
-    const componentsDir = path13.join(srcPath, "components", "authverse");
-    if (!fs13.existsSync(componentsDir)) {
-      fs13.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = path17.join(srcPath, "components", "authverse");
+    if (!fs17.existsSync(componentsDir)) {
+      fs17.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = path13.join(componentsDir, "FacebookOAuthButton.tsx");
-    if (fs13.existsSync(componentTemplate)) {
-      fs13.copyFileSync(componentTemplate, componentDest);
+    const componentDest = path17.join(componentsDir, "FacebookOAuthButton.tsx");
+    if (fs17.existsSync(componentTemplate)) {
+      fs17.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk13.green("Facebook provider added & merged successfully\n"));
+    console.log(chalk17.green("Facebook provider added & merged successfully\n"));
     console.log(
-      chalk13.white("\u2022 src/components/authverse/FacebookOAuthButton.tsx")
+      chalk17.white("\u2022 src/components/authverse/FacebookOAuthButton.tsx")
     );
   } catch (error) {
-    console.log(chalk13.red("facebookRunTanstackState error:"), error);
+    console.log(chalk17.red("facebookRunTanstackState error:"), error);
   }
 };
 
 // oauth/LinkedInNext.ts
-import chalk14 from "chalk";
-import fs14 from "fs";
-import path14 from "path";
-import { fileURLToPath as fileURLToPath13 } from "url";
+import chalk18 from "chalk";
+import fs18 from "fs";
+import path18 from "path";
+import { fileURLToPath as fileURLToPath15 } from "url";
 var LinkedInNext = async () => {
   try {
-    const __filename = fileURLToPath13(import.meta.url);
-    const __dirname = path14.dirname(__filename);
+    const __filename = fileURLToPath15(import.meta.url);
+    const __dirname = path18.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = path14.join(projectDir, "src");
-    const folder = fs14.existsSync(srcPath) ? "src" : "";
-    const authFilePath = path14.join(projectDir, folder, "lib", "auth.ts");
-    if (!fs14.existsSync(authFilePath)) {
-      console.log(chalk14.red("No Configured Better Auth file found"));
-      console.log(chalk14.cyan("Run authverse init to initialize better auth"));
+    const srcPath = path18.join(projectDir, "src");
+    const folder = fs18.existsSync(srcPath) ? "src" : "";
+    const authFilePath = path18.join(projectDir, folder, "lib", "auth.ts");
+    if (!fs18.existsSync(authFilePath)) {
+      console.log(chalk18.red("No Configured Better Auth file found"));
+      console.log(chalk18.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = fs14.readFileSync(authFilePath, "utf8");
+    let content = fs18.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk14.red("betterAuth({}) block not found"));
+      console.log(chalk18.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("LinkedIn:")) {
-      console.log(chalk14.yellow("LinkedIn provider already exists"));
+      console.log(chalk18.yellow("LinkedIn provider already exists"));
       return;
     }
     const LinkedInProviderEntry = `
@@ -1819,7 +2354,7 @@ var LinkedInNext = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk14.red("Failed to parse socialProviders block"));
+        console.log(chalk18.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + LinkedInProviderEntry + "\n  " + content.slice(insertPos);
@@ -1827,7 +2362,7 @@ var LinkedInNext = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk14.red(
+          chalk18.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1843,12 +2378,12 @@ ${LinkedInProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    fs14.writeFileSync(authFilePath, content, "utf8");
-    const envPath = path14.join(projectDir, ".env");
-    if (fs14.existsSync(envPath)) {
-      const envContent = fs14.readFileSync(envPath, "utf8");
+    fs18.writeFileSync(authFilePath, content, "utf8");
+    const envPath = path18.join(projectDir, ".env");
+    if (fs18.existsSync(envPath)) {
+      const envContent = fs18.readFileSync(envPath, "utf8");
       if (!envContent.includes("LINKEDIN_CLIENT_ID")) {
-        fs14.appendFileSync(
+        fs18.appendFileSync(
           envPath,
           `
 
@@ -1859,59 +2394,59 @@ LINKEDIN_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = path14.resolve(
+    const componentTemplate = path18.resolve(
       __dirname,
       "./template/components/LinkedInOAuthButton.tsx"
     );
-    const componentsDir = path14.join(
+    const componentsDir = path18.join(
       projectDir,
       folder,
       "components",
       "authverse"
     );
-    if (!fs14.existsSync(componentsDir)) {
-      fs14.mkdirSync(componentsDir, { recursive: true });
+    if (!fs18.existsSync(componentsDir)) {
+      fs18.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = path14.join(componentsDir, "LinkedInOAuthButton.tsx");
-    if (fs14.existsSync(componentTemplate)) {
-      fs14.copyFileSync(componentTemplate, componentDest);
+    const componentDest = path18.join(componentsDir, "LinkedInOAuthButton.tsx");
+    if (fs18.existsSync(componentTemplate)) {
+      fs18.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk14.green("LinkedIn provider added & merged successfully\n"));
+    console.log(chalk18.green("LinkedIn provider added & merged successfully\n"));
     console.log(
-      chalk14.white(
+      chalk18.white(
         `${CreateFolder({ srcFolder: folder, destFolder: "components/authverse/LinkedInOAuthButton.tsx" })}
 `
       )
     );
   } catch (error) {
-    console.log(chalk14.red("LinkedIn error:"), error);
+    console.log(chalk18.red("LinkedIn error:"), error);
   }
 };
 
 // oauth/LinkedInTanstackStart.ts
-import chalk15 from "chalk";
-import fs15 from "fs";
-import path15 from "path";
-import { fileURLToPath as fileURLToPath14 } from "url";
+import chalk19 from "chalk";
+import fs19 from "fs";
+import path19 from "path";
+import { fileURLToPath as fileURLToPath16 } from "url";
 var LinkedInTanstackStart = async () => {
   try {
-    const __filename = fileURLToPath14(import.meta.url);
-    const __dirname = path15.dirname(__filename);
+    const __filename = fileURLToPath16(import.meta.url);
+    const __dirname = path19.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = path15.join(projectDir, "src");
-    const authFilePath = path15.join(srcPath, "lib", "auth.ts");
-    if (!fs15.existsSync(authFilePath)) {
-      console.log(chalk15.red("No Configured Better Auth file found"));
-      console.log(chalk15.cyan("Run authverse init to initialize better auth"));
+    const srcPath = path19.join(projectDir, "src");
+    const authFilePath = path19.join(srcPath, "lib", "auth.ts");
+    if (!fs19.existsSync(authFilePath)) {
+      console.log(chalk19.red("No Configured Better Auth file found"));
+      console.log(chalk19.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = fs15.readFileSync(authFilePath, "utf8");
+    let content = fs19.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk15.red("betterAuth({}) block not found"));
+      console.log(chalk19.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("linkedin:")) {
-      console.log(chalk15.yellow("LinkedIn provider already exists"));
+      console.log(chalk19.yellow("LinkedIn provider already exists"));
       return;
     }
     const LinkedInProviderEntry = `
@@ -1934,7 +2469,7 @@ var LinkedInTanstackStart = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk15.red("Failed to parse socialProviders block"));
+        console.log(chalk19.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + LinkedInProviderEntry + "\n  " + content.slice(insertPos);
@@ -1942,7 +2477,7 @@ var LinkedInTanstackStart = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk15.red(
+          chalk19.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1958,12 +2493,12 @@ ${LinkedInProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    fs15.writeFileSync(authFilePath, content, "utf8");
-    const envPath = path15.join(projectDir, ".env");
-    if (fs15.existsSync(envPath)) {
-      const envContent = fs15.readFileSync(envPath, "utf8");
+    fs19.writeFileSync(authFilePath, content, "utf8");
+    const envPath = path19.join(projectDir, ".env");
+    if (fs19.existsSync(envPath)) {
+      const envContent = fs19.readFileSync(envPath, "utf8");
       if (!envContent.includes("LINKEDIN_CLIENT_ID")) {
-        fs15.appendFileSync(
+        fs19.appendFileSync(
           envPath,
           `
 
@@ -1974,52 +2509,52 @@ LINKEDIN_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = path15.resolve(
+    const componentTemplate = path19.resolve(
       __dirname,
       "./template/TanstackStart/components/LinkedInOAuthButton.tsx"
     );
-    const componentsDir = path15.join(srcPath, "components", "authverse");
-    if (!fs15.existsSync(componentsDir)) {
-      fs15.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = path19.join(srcPath, "components", "authverse");
+    if (!fs19.existsSync(componentsDir)) {
+      fs19.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = path15.join(componentsDir, "LinkedInOAuthButton.tsx");
-    if (fs15.existsSync(componentTemplate)) {
-      fs15.copyFileSync(componentTemplate, componentDest);
+    const componentDest = path19.join(componentsDir, "LinkedInOAuthButton.tsx");
+    if (fs19.existsSync(componentTemplate)) {
+      fs19.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk15.green("LinkedIn provider added & merged successfully\n"));
+    console.log(chalk19.green("LinkedIn provider added & merged successfully\n"));
     console.log(
-      chalk15.white("\u2022 src/components/authverse/LinkedInOAuthButton.tsx")
+      chalk19.white("\u2022 src/components/authverse/LinkedInOAuthButton.tsx")
     );
   } catch (error) {
-    console.log(chalk15.red("LinkedInTanstackState error:"), error);
+    console.log(chalk19.red("LinkedInTanstackState error:"), error);
   }
 };
 
 // oauth/twitterNext.ts
-import chalk16 from "chalk";
-import fs16 from "fs";
-import path16 from "path";
-import { fileURLToPath as fileURLToPath15 } from "url";
+import chalk20 from "chalk";
+import fs20 from "fs";
+import path20 from "path";
+import { fileURLToPath as fileURLToPath17 } from "url";
 var twitterNext = async () => {
   try {
-    const __filename = fileURLToPath15(import.meta.url);
-    const __dirname = path16.dirname(__filename);
+    const __filename = fileURLToPath17(import.meta.url);
+    const __dirname = path20.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = path16.join(projectDir, "src");
-    const folder = fs16.existsSync(srcPath) ? "src" : "";
-    const authFilePath = path16.join(projectDir, folder, "lib", "auth.ts");
-    if (!fs16.existsSync(authFilePath)) {
-      console.log(chalk16.red("No Configured Better Auth file found"));
-      console.log(chalk16.cyan("Run authverse init to initialize better auth"));
+    const srcPath = path20.join(projectDir, "src");
+    const folder = fs20.existsSync(srcPath) ? "src" : "";
+    const authFilePath = path20.join(projectDir, folder, "lib", "auth.ts");
+    if (!fs20.existsSync(authFilePath)) {
+      console.log(chalk20.red("No Configured Better Auth file found"));
+      console.log(chalk20.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = fs16.readFileSync(authFilePath, "utf8");
+    let content = fs20.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk16.red("betterAuth({}) block not found"));
+      console.log(chalk20.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("twitter:")) {
-      console.log(chalk16.yellow("twitter provider already exists"));
+      console.log(chalk20.yellow("twitter provider already exists"));
       return;
     }
     const twitterProviderEntry = `
@@ -2042,7 +2577,7 @@ var twitterNext = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk16.red("Failed to parse socialProviders block"));
+        console.log(chalk20.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + twitterProviderEntry + "\n  " + content.slice(insertPos);
@@ -2050,7 +2585,7 @@ var twitterNext = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk16.red(
+          chalk20.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -2066,12 +2601,12 @@ ${twitterProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    fs16.writeFileSync(authFilePath, content, "utf8");
-    const envPath = path16.join(projectDir, ".env");
-    if (fs16.existsSync(envPath)) {
-      const envContent = fs16.readFileSync(envPath, "utf8");
+    fs20.writeFileSync(authFilePath, content, "utf8");
+    const envPath = path20.join(projectDir, ".env");
+    if (fs20.existsSync(envPath)) {
+      const envContent = fs20.readFileSync(envPath, "utf8");
       if (!envContent.includes("TWITTER_CLIENT_ID")) {
-        fs16.appendFileSync(
+        fs20.appendFileSync(
           envPath,
           `
 
@@ -2082,59 +2617,59 @@ TWITTER_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = path16.resolve(
+    const componentTemplate = path20.resolve(
       __dirname,
       "./template/components/twitterOAuthButton.tsx"
     );
-    const componentsDir = path16.join(
+    const componentsDir = path20.join(
       projectDir,
       folder,
       "components",
       "authverse"
     );
-    if (!fs16.existsSync(componentsDir)) {
-      fs16.mkdirSync(componentsDir, { recursive: true });
+    if (!fs20.existsSync(componentsDir)) {
+      fs20.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = path16.join(componentsDir, "twitterOAuthButton.tsx");
-    if (fs16.existsSync(componentTemplate)) {
-      fs16.copyFileSync(componentTemplate, componentDest);
+    const componentDest = path20.join(componentsDir, "twitterOAuthButton.tsx");
+    if (fs20.existsSync(componentTemplate)) {
+      fs20.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk16.green("Twitter provider added & merged successfully\n"));
+    console.log(chalk20.green("Twitter provider added & merged successfully\n"));
     console.log(
-      chalk16.white(
+      chalk20.white(
         `${CreateFolder({ srcFolder: folder, destFolder: "components/authverse/TwitterOAuthButton.tsx" })}
 `
       )
     );
   } catch (error) {
-    console.log(chalk16.red("twitter error:"), error);
+    console.log(chalk20.red("twitter error:"), error);
   }
 };
 
 // oauth/twitterTanstackStart.ts
-import chalk17 from "chalk";
-import fs17 from "fs";
-import path17 from "path";
-import { fileURLToPath as fileURLToPath16 } from "url";
+import chalk21 from "chalk";
+import fs21 from "fs";
+import path21 from "path";
+import { fileURLToPath as fileURLToPath18 } from "url";
 var twitterTanstackStart = async () => {
   try {
-    const __filename = fileURLToPath16(import.meta.url);
-    const __dirname = path17.dirname(__filename);
+    const __filename = fileURLToPath18(import.meta.url);
+    const __dirname = path21.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = path17.join(projectDir, "src");
-    const authFilePath = path17.join(srcPath, "lib", "auth.ts");
-    if (!fs17.existsSync(authFilePath)) {
-      console.log(chalk17.red("No Configured Better Auth file found"));
-      console.log(chalk17.cyan("Run authverse init to initialize better auth"));
+    const srcPath = path21.join(projectDir, "src");
+    const authFilePath = path21.join(srcPath, "lib", "auth.ts");
+    if (!fs21.existsSync(authFilePath)) {
+      console.log(chalk21.red("No Configured Better Auth file found"));
+      console.log(chalk21.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = fs17.readFileSync(authFilePath, "utf8");
+    let content = fs21.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk17.red("betterAuth({}) block not found"));
+      console.log(chalk21.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("twitter:")) {
-      console.log(chalk17.yellow("twitter provider already exists"));
+      console.log(chalk21.yellow("twitter provider already exists"));
       return;
     }
     const twitterProviderEntry = `
@@ -2157,7 +2692,7 @@ var twitterTanstackStart = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk17.red("Failed to parse socialProviders block"));
+        console.log(chalk21.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + twitterProviderEntry + "\n  " + content.slice(insertPos);
@@ -2165,7 +2700,7 @@ var twitterTanstackStart = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk17.red(
+          chalk21.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -2181,12 +2716,12 @@ ${twitterProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    fs17.writeFileSync(authFilePath, content, "utf8");
-    const envPath = path17.join(projectDir, ".env");
-    if (fs17.existsSync(envPath)) {
-      const envContent = fs17.readFileSync(envPath, "utf8");
+    fs21.writeFileSync(authFilePath, content, "utf8");
+    const envPath = path21.join(projectDir, ".env");
+    if (fs21.existsSync(envPath)) {
+      const envContent = fs21.readFileSync(envPath, "utf8");
       if (!envContent.includes("TWITTER_CLIENT_ID")) {
-        fs17.appendFileSync(
+        fs21.appendFileSync(
           envPath,
           `
 
@@ -2197,53 +2732,53 @@ TWITTER_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = path17.resolve(
+    const componentTemplate = path21.resolve(
       __dirname,
       "./template/TanstackStart/components/twitterOAuthButton.tsx"
     );
-    const componentsDir = path17.join(srcPath, "components", "authverse");
-    if (!fs17.existsSync(componentsDir)) {
-      fs17.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = path21.join(srcPath, "components", "authverse");
+    if (!fs21.existsSync(componentsDir)) {
+      fs21.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = path17.join(componentsDir, "twitterOAuthButton.tsx");
-    if (fs17.existsSync(componentTemplate)) {
-      fs17.copyFileSync(componentTemplate, componentDest);
+    const componentDest = path21.join(componentsDir, "twitterOAuthButton.tsx");
+    if (fs21.existsSync(componentTemplate)) {
+      fs21.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk17.green("twitter provider added & merged successfully\n"));
+    console.log(chalk21.green("twitter provider added & merged successfully\n"));
     console.log(
-      chalk17.white("\u2022 src/components/authverse/twitterOAuthButton.tsx")
+      chalk21.white("\u2022 src/components/authverse/twitterOAuthButton.tsx")
     );
   } catch (error) {
-    console.log(chalk17.red("twitter tanstack state error:"), error);
+    console.log(chalk21.red("twitter tanstack state error:"), error);
   }
 };
 
 // oauth/AppleNext.ts
-import chalk18 from "chalk";
-import fs18 from "fs";
-import path18 from "path";
-import { fileURLToPath as fileURLToPath17 } from "url";
+import chalk22 from "chalk";
+import fs22 from "fs";
+import path22 from "path";
+import { fileURLToPath as fileURLToPath19 } from "url";
 var AppleNext = async () => {
   try {
-    const __filename = fileURLToPath17(import.meta.url);
-    const __dirname = path18.dirname(__filename);
+    const __filename = fileURLToPath19(import.meta.url);
+    const __dirname = path22.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = path18.join(projectDir, "src");
-    const folder = fs18.existsSync(srcPath) ? "src" : "";
-    const authFilePath = path18.join(projectDir, folder, "lib", "auth.ts");
-    if (!fs18.existsSync(authFilePath)) {
-      console.log(chalk18.red("No Configured Better Auth file found"));
-      console.log(chalk18.cyan("Run authverse init to initialize better auth"));
+    const srcPath = path22.join(projectDir, "src");
+    const folder = fs22.existsSync(srcPath) ? "src" : "";
+    const authFilePath = path22.join(projectDir, folder, "lib", "auth.ts");
+    if (!fs22.existsSync(authFilePath)) {
+      console.log(chalk22.red("No Configured Better Auth file found"));
+      console.log(chalk22.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = fs18.readFileSync(authFilePath, "utf8");
+    let content = fs22.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk18.red("betterAuth({}) block not found"));
-      console.log(chalk18.cyan("Run authverse init to initialize better auth"));
+      console.log(chalk22.red("betterAuth({}) block not found"));
+      console.log(chalk22.cyan("Run authverse init to initialize better auth"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("apple:")) {
-      console.log(chalk18.yellow("Apple provider already exists"));
+      console.log(chalk22.yellow("Apple provider already exists"));
       return;
     }
     const appleProviderEntry = `
@@ -2268,7 +2803,7 @@ var AppleNext = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk18.red("Failed to parse socialProviders block"));
+        console.log(chalk22.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + appleProviderEntry + "\n  " + content.slice(insertPos);
@@ -2276,7 +2811,7 @@ var AppleNext = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk18.red(
+          chalk22.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -2306,12 +2841,12 @@ ${socialProvidersBlock}`
         content = content.slice(0, insertPos) + '\n  trustedOrigins: ["https://appleid.apple.com"],' + content.slice(insertPos);
       }
     }
-    fs18.writeFileSync(authFilePath, content, "utf8");
-    const envPath = path18.join(projectDir, ".env");
-    if (fs18.existsSync(envPath)) {
-      const envContent = fs18.readFileSync(envPath, "utf8");
+    fs22.writeFileSync(authFilePath, content, "utf8");
+    const envPath = path22.join(projectDir, ".env");
+    if (fs22.existsSync(envPath)) {
+      const envContent = fs22.readFileSync(envPath, "utf8");
       if (!envContent.includes("APPLE_CLIENT_ID")) {
-        fs18.appendFileSync(
+        fs22.appendFileSync(
           envPath,
           `
 
@@ -2323,59 +2858,59 @@ APPLE_BUNDLE_ID=
         );
       }
     }
-    const componentTemplate = path18.resolve(
+    const componentTemplate = path22.resolve(
       __dirname,
       "./template/components/AppleOAuthButton.tsx"
     );
-    const componentsDir = path18.join(
+    const componentsDir = path22.join(
       projectDir,
       folder,
       "components",
       "authverse"
     );
-    if (!fs18.existsSync(componentsDir)) {
-      fs18.mkdirSync(componentsDir, { recursive: true });
+    if (!fs22.existsSync(componentsDir)) {
+      fs22.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = path18.join(componentsDir, "AppleOAuthButton.tsx");
-    if (fs18.existsSync(componentTemplate)) {
-      fs18.copyFileSync(componentTemplate, componentDest);
+    const componentDest = path22.join(componentsDir, "AppleOAuthButton.tsx");
+    if (fs22.existsSync(componentTemplate)) {
+      fs22.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk18.green("Apple provider added & merged successfully\n"));
+    console.log(chalk22.green("Apple provider added & merged successfully\n"));
     console.log(
-      chalk18.white(
+      chalk22.white(
         `${CreateFolder({ srcFolder: folder, destFolder: "components/authverse/AppleOAuthButton.tsx" })}
 `
       )
     );
   } catch (error) {
-    console.log(chalk18.red("apple next error:"), error);
+    console.log(chalk22.red("apple next error:"), error);
   }
-};
-
-// oauth/AppleTanstackStart.ts
-import chalk19 from "chalk";
-import fs19 from "fs";
-import path19 from "path";
-import { fileURLToPath as fileURLToPath18 } from "url";
+};
+
+// oauth/AppleTanstackStart.ts
+import chalk23 from "chalk";
+import fs23 from "fs";
+import path23 from "path";
+import { fileURLToPath as fileURLToPath20 } from "url";
 var AppleTanstackStart = async () => {
   try {
-    const __filename = fileURLToPath18(import.meta.url);
-    const __dirname = path19.dirname(__filename);
+    const __filename = fileURLToPath20(import.meta.url);
+    const __dirname = path23.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = path19.join(projectDir, "src");
-    const authFilePath = path19.join(srcPath, "lib", "auth.ts");
-    if (!fs19.existsSync(authFilePath)) {
-      console.log(chalk19.red("No Configured Better Auth file found"));
-      console.log(chalk19.cyan("Run authverse init to initialize better auth"));
+    const srcPath = path23.join(projectDir, "src");
+    const authFilePath = path23.join(srcPath, "lib", "auth.ts");
+    if (!fs23.existsSync(authFilePath)) {
+      console.log(chalk23.red("No Configured Better Auth file found"));
+      console.log(chalk23.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = fs19.readFileSync(authFilePath, "utf8");
+    let content = fs23.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk19.red("betterAuth({}) block not found"));
+      console.log(chalk23.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("apple:")) {
-      console.log(chalk19.yellow("Apple provider already exists"));
+      console.log(chalk23.yellow("Apple provider already exists"));
       return;
     }
     const appleProviderEntry = `
@@ -2400,7 +2935,7 @@ var AppleTanstackStart = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk19.red("Failed to parse socialProviders block"));
+        console.log(chalk23.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + appleProviderEntry + "\n  " + content.slice(insertPos);
@@ -2408,7 +2943,7 @@ var AppleTanstackStart = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk19.red(
+          chalk23.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -2438,12 +2973,12 @@ ${socialProvidersBlock}`
         content = content.slice(0, insertPos) + '\n  trustedOrigins: ["https://appleid.apple.com"],' + content.slice(insertPos);
       }
     }
-    fs19.writeFileSync(authFilePath, content, "utf8");
-    const envPath = path19.join(projectDir, ".env");
-    if (fs19.existsSync(envPath)) {
-      const envContent = fs19.readFileSync(envPath, "utf8");
+    fs23.writeFileSync(authFilePath, content, "utf8");
+    const envPath = path23.join(projectDir, ".env");
+    if (fs23.existsSync(envPath)) {
+      const envContent = fs23.readFileSync(envPath, "utf8");
       if (!envContent.includes("APPLE_CLIENT_ID")) {
-        fs19.appendFileSync(
+        fs23.appendFileSync(
           envPath,
           `
 
@@ -2455,22 +2990,22 @@ APPLE_BUNDLE_ID=
         );
       }
     }
-    const componentTemplate = path19.resolve(
+    const componentTemplate = path23.resolve(
       __dirname,
       "./template/TanstackStart/components/AppleOAuthButton.tsx"
     );
-    const componentsDir = path19.join(srcPath, "components", "authverse");
-    if (!fs19.existsSync(componentsDir)) {
-      fs19.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = path23.join(srcPath, "components", "authverse");
+    if (!fs23.existsSync(componentsDir)) {
+      fs23.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = path19.join(componentsDir, "AppleOAuthButton.tsx");
-    if (fs19.existsSync(componentTemplate)) {
-      fs19.copyFileSync(componentTemplate, componentDest);
+    const componentDest = path23.join(componentsDir, "AppleOAuthButton.tsx");
+    if (fs23.existsSync(componentTemplate)) {
+      fs23.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk19.green("Apple provider added & merged successfully\n"));
-    console.log(chalk19.white("\u2022 src/components/authverse/AppleOAuthButton.tsx"));
+    console.log(chalk23.green("Apple provider added & merged successfully\n"));
+    console.log(chalk23.white("\u2022 src/components/authverse/AppleOAuthButton.tsx"));
   } catch (error) {
-    console.log(chalk19.red("apple tanstack state error:"), error);
+    console.log(chalk23.red("apple tanstack state error:"), error);
   }
 };
 
@@ -2479,7 +3014,7 @@ var Oauth = async ({ oauth }) => {
   try {
     const { framework, error } = await getFramework();
     if (error) {
-      console.log(chalk20.red(error));
+      console.log(chalk24.red(error));
       return;
     }
     if (framework === "Next js" && oauth == "google") {
@@ -2513,455 +3048,459 @@ var Oauth = async ({ oauth }) => {
       await AppleTanstackStart();
     }
     if (oauth !== "google" && oauth !== "github" && oauth !== "facebook" && oauth !== "LinkedIn" && oauth !== "twitter" && oauth !== "apple") {
-      console.log(chalk20.red("Invalid oauth provider"));
+      console.log(chalk24.red("Invalid oauth provider"));
       return;
     }
   } catch (error) {
-    console.log(chalk20.red("Error adding oauth:"), error);
+    console.log(chalk24.red("Error adding oauth:"), error);
   }
 };
 
 // script/forgetNext.ts
-import chalk28 from "chalk";
-import path27 from "path";
-import { fileURLToPath as fileURLToPath25 } from "url";
-import fs27 from "fs";
+import chalk32 from "chalk";
+import path31 from "path";
+import { fileURLToPath as fileURLToPath27 } from "url";
+import fs31 from "fs";
 
 // cli/email.ts
-import path26 from "path";
-import fs26 from "fs";
-import inquirer4 from "inquirer";
+import path30 from "path";
+import fs30 from "fs";
+import inquirer5 from "inquirer";
 
 // email/gmailRun.ts
-import chalk21 from "chalk";
-import path20 from "path";
-import fs20 from "fs";
-import { fileURLToPath as fileURLToPath19 } from "url";
+import chalk25 from "chalk";
+import path24 from "path";
+import fs24 from "fs";
+import { fileURLToPath as fileURLToPath21 } from "url";
 var gmailRun = async () => {
   try {
     const projectDir = process.cwd();
-    const packageJsonPath = path20.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(fs20.readFileSync(packageJsonPath, "utf-8"));
-    const srcFolder = fs20.existsSync(path20.join(projectDir, "src")) ? "src" : "";
-    const __filename = fileURLToPath19(import.meta.url);
-    const __dirname = path20.dirname(__filename);
+    const packageJsonPath = path24.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(fs24.readFileSync(packageJsonPath, "utf-8"));
+    const srcFolder = fs24.existsSync(path24.join(projectDir, "src")) ? "src" : "";
+    const __filename = fileURLToPath21(import.meta.url);
+    const __dirname = path24.dirname(__filename);
     if (!packageJson2.dependencies?.nodemailer || !packageJson2.devDependencies?.["@types/nodemailer"]) {
-      console.log(chalk21.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
+      console.log(chalk25.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
       packageManager("nodemailer");
       packageManager("@types/nodemailer", true);
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(chalk21.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      console.log(chalk25.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
       packageManager("@react-email/components");
     }
     if (!packageJson2.dependencies?.["@react-email/render"]) {
-      console.log(chalk21.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
+      console.log(chalk25.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
       packageManager("@react-email/render");
     }
-    const envPath = path20.join(projectDir, ".env");
-    const envContent = fs20.readFileSync(envPath, "utf8");
+    const envPath = path24.join(projectDir, ".env");
+    const envContent = fs24.readFileSync(envPath, "utf8");
     if (!envContent.includes("GMAIL_HOST") && !envContent.includes("GMAIL_PORT") && !envContent.includes("GMAIL_SERVICE") && !envContent.includes("GMAIL_MAIL") && !envContent.includes("GMAIL_NAME") && !envContent.includes("GMAIL_PASSWORD")) {
-      fs20.appendFileSync(envPath, `
+      fs24.appendFileSync(envPath, `
 
 # Gmail API Key for sending emails`);
-      fs20.appendFileSync(envPath, `
+      fs24.appendFileSync(envPath, `
 GMAIL_HOST=`);
-      fs20.appendFileSync(envPath, `
+      fs24.appendFileSync(envPath, `
 GMAIL_PORT=`);
-      fs20.appendFileSync(envPath, `
+      fs24.appendFileSync(envPath, `
 GMAIL_SERVICE=`);
-      fs20.appendFileSync(envPath, `
+      fs24.appendFileSync(envPath, `
 GMAIL_MAIL=`);
-      fs20.appendFileSync(envPath, `
+      fs24.appendFileSync(envPath, `
 GMAIL_NAME=`);
-      fs20.appendFileSync(envPath, `
+      fs24.appendFileSync(envPath, `
 GMAIL_PASSWORD=`);
     }
-    const templatePath = path20.resolve(
+    const templatePath = path24.resolve(
       __dirname,
       "./template/email/emailGmail.ts"
     );
-    const libPath = path20.join(projectDir, srcFolder, "lib");
-    if (!fs20.existsSync(libPath)) {
-      fs20.mkdirSync(libPath, { recursive: true });
+    const libPath = path24.join(projectDir, srcFolder, "lib");
+    if (!fs24.existsSync(libPath)) {
+      fs24.mkdirSync(libPath, { recursive: true });
     }
-    const libDestinationPath = path20.join(libPath, "email.ts");
-    fs20.copyFileSync(templatePath, libDestinationPath);
-    console.log(chalk21.green("\nCompleted installation successfully"));
-    console.log(chalk21.cyan("\nInstall Package:"));
+    const libDestinationPath = path24.join(libPath, "email.ts");
+    fs24.copyFileSync(templatePath, libDestinationPath);
+    console.log(chalk25.green("\nCompleted installation successfully"));
+    console.log(chalk25.cyan("\nInstall Package:"));
     console.log(
-      chalk21.white(
+      chalk25.white(
         `\u2022 nodemailer
 \u2022 @react-email/components
 \u2022 @react-email/render`
       )
     );
-    console.log(chalk21.cyan("\nFiles created:"));
+    console.log(chalk25.cyan("\nFiles created:"));
     console.log(
-      chalk21.white(
+      chalk25.white(
         `${CreateFolder({ srcFolder, destFolder: "lib/email.ts" })}
 `
       )
     );
   } catch (error) {
-    console.log(chalk21.red(error));
+    console.log(chalk25.red(error));
   }
 };
 
 // email/gmailRunTanstackStart.ts
-import chalk22 from "chalk";
-import path21 from "path";
-import fs21 from "fs";
-import { fileURLToPath as fileURLToPath20 } from "url";
+import chalk26 from "chalk";
+import path25 from "path";
+import fs25 from "fs";
+import { fileURLToPath as fileURLToPath22 } from "url";
 var gmailRunTanstackStart = async () => {
   try {
     const projectDir = process.cwd();
-    const packageJsonPath = path21.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(fs21.readFileSync(packageJsonPath, "utf-8"));
-    const __filename = fileURLToPath20(import.meta.url);
-    const __dirname = path21.dirname(__filename);
+    const packageJsonPath = path25.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(fs25.readFileSync(packageJsonPath, "utf-8"));
+    const __filename = fileURLToPath22(import.meta.url);
+    const __dirname = path25.dirname(__filename);
     if (!packageJson2.dependencies?.nodemailer || !packageJson2.devDependencies?.["@types/nodemailer"]) {
-      console.log(chalk22.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
+      console.log(chalk26.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
       packageManager("nodemailer");
       packageManager("@types/nodemailer", true);
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(chalk22.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      console.log(chalk26.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
       packageManager("@react-email/components");
     }
     if (!packageJson2.dependencies?.["@react-email/render"]) {
-      console.log(chalk22.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
+      console.log(chalk26.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
       packageManager("@react-email/render");
     }
-    const envPath = path21.join(projectDir, ".env");
-    const envContent = fs21.readFileSync(envPath, "utf8");
+    const envPath = path25.join(projectDir, ".env");
+    const envContent = fs25.readFileSync(envPath, "utf8");
     if (!envContent.includes("GMAIL_HOST") && !envContent.includes("GMAIL_PORT") && !envContent.includes("GMAIL_SERVICE") && !envContent.includes("GMAIL_MAIL") && !envContent.includes("GMAIL_NAME") && !envContent.includes("GMAIL_PASSWORD")) {
-      fs21.appendFileSync(envPath, `
+      fs25.appendFileSync(envPath, `
 
 # Gmail API Key for sending emails`);
-      fs21.appendFileSync(envPath, `
+      fs25.appendFileSync(envPath, `
 GMAIL_HOST=`);
-      fs21.appendFileSync(envPath, `
+      fs25.appendFileSync(envPath, `
 GMAIL_PORT=`);
-      fs21.appendFileSync(envPath, `
+      fs25.appendFileSync(envPath, `
 GMAIL_SERVICE=`);
-      fs21.appendFileSync(envPath, `
+      fs25.appendFileSync(envPath, `
 GMAIL_MAIL=`);
-      fs21.appendFileSync(envPath, `
+      fs25.appendFileSync(envPath, `
 GMAIL_NAME=`);
-      fs21.appendFileSync(envPath, `
+      fs25.appendFileSync(envPath, `
 GMAIL_PASSWORD=`);
     }
-    const templatePath = path21.resolve(
+    const templatePath = path25.resolve(
       __dirname,
       "./template/email/emailGmail.ts"
     );
-    const libPath = path21.join(projectDir, "src", "lib");
-    if (!fs21.existsSync(libPath)) {
-      fs21.mkdirSync(libPath, { recursive: true });
+    const libPath = path25.join(projectDir, "src", "lib");
+    if (!fs25.existsSync(libPath)) {
+      fs25.mkdirSync(libPath, { recursive: true });
     }
-    const libDestinationPath = path21.join(libPath, "email.ts");
-    fs21.copyFileSync(templatePath, libDestinationPath);
-    console.log(chalk22.green("\nCompleted installation successfully"));
-    console.log(chalk22.cyan("\nInstall Package:"));
+    const libDestinationPath = path25.join(libPath, "email.ts");
+    fs25.copyFileSync(templatePath, libDestinationPath);
+    console.log(chalk26.green("\nCompleted installation successfully"));
+    console.log(chalk26.cyan("\nInstall Package:"));
     console.log(
-      chalk22.white(
+      chalk26.white(
         `\u2022 nodemailer
 \u2022 @react-email/components
 \u2022 @react-email/render`
       )
     );
-    console.log(chalk22.cyan("\nFiles created:"));
-    console.log(chalk22.white("\u2022 src/lib/email.ts\n"));
+    console.log(chalk26.cyan("\nFiles created:"));
+    console.log(chalk26.white("\u2022 src/lib/email.ts\n"));
   } catch (error) {
-    console.log(chalk22.red(error));
+    console.log(chalk26.red(error));
   }
 };
 
 // email/awsSesRun.ts
-import chalk23 from "chalk";
-import path22 from "path";
-import fs22 from "fs";
-import { fileURLToPath as fileURLToPath21 } from "url";
+import chalk27 from "chalk";
+import path26 from "path";
+import fs26 from "fs";
+import { fileURLToPath as fileURLToPath23 } from "url";
 var awsSesRun = async () => {
   try {
     const projectDir = process.cwd();
-    const packageJsonPath = path22.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(fs22.readFileSync(packageJsonPath, "utf-8"));
-    const srcFolder = fs22.existsSync(path22.join(projectDir, "src")) ? "src" : "";
-    const __filename = fileURLToPath21(import.meta.url);
-    const __dirname = path22.dirname(__filename);
+    const packageJsonPath = path26.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(fs26.readFileSync(packageJsonPath, "utf-8"));
+    const srcFolder = fs26.existsSync(path26.join(projectDir, "src")) ? "src" : "";
+    const __filename = fileURLToPath23(import.meta.url);
+    const __dirname = path26.dirname(__filename);
     if (!packageJson2.dependencies?.nodemailer || !packageJson2.devDependencies?.["@types/nodemailer"]) {
-      console.log(chalk23.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
+      console.log(chalk27.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
       packageManager("nodemailer");
       packageManager("@types/nodemailer", true);
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(chalk23.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      console.log(chalk27.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
       packageManager("@react-email/components");
     }
     if (!packageJson2.dependencies?.["@react-email/render"]) {
-      console.log(chalk23.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
+      console.log(chalk27.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
       packageManager("@react-email/render");
     }
-    const envPath = path22.join(projectDir, ".env");
-    const envContent = fs22.readFileSync(envPath, "utf8");
-    if (!envContent.includes("AWS_SES_HOST") && !envContent.includes("AWS_SES_PORT") && !envContent.includes("AWS_SES_SERVICE") && !envContent.includes("AWS_SES_USER") && !envContent.includes("AWS_SES_PASS") && !envContent.includes("AWS_SES_FROM")) {
-      fs22.appendFileSync(envPath, `
+    const envPath = path26.join(projectDir, ".env");
+    const envContent = fs26.readFileSync(envPath, "utf8");
+    if (!envContent.includes("AWS_SES_HOST") && !envContent.includes("AWS_SES_PORT") && !envContent.includes("AWS_SES_SERVICE") && !envContent.includes("AWS_SES_USER") && !envContent.includes("AWS_SES_PASS") && !envContent.includes("AWS_SES_FROM") && !envContent.includes("AWS_SES_FROM_NAME")) {
+      fs26.appendFileSync(envPath, `
 
 # AWS SES API Key for sending emails`);
-      fs22.appendFileSync(envPath, `
+      fs26.appendFileSync(envPath, `
 AWS_SES_HOST=`);
-      fs22.appendFileSync(envPath, `
+      fs26.appendFileSync(envPath, `
 AWS_SES_PORT=`);
-      fs22.appendFileSync(envPath, `
+      fs26.appendFileSync(envPath, `
 AWS_SES_SERVICE=`);
-      fs22.appendFileSync(envPath, `
+      fs26.appendFileSync(envPath, `
 AWS_SES_USER=`);
-      fs22.appendFileSync(envPath, `
+      fs26.appendFileSync(envPath, `
 AWS_SES_PASS=`);
-      fs22.appendFileSync(envPath, `
+      fs26.appendFileSync(envPath, `
 AWS_SES_FROM=`);
+      fs26.appendFileSync(envPath, `
+AWS_SES_FROM_NAME=`);
     }
-    const templatePath = path22.resolve(
+    const templatePath = path26.resolve(
       __dirname,
       "./template/email/emailAwsSes.ts"
     );
-    const libPath = path22.join(projectDir, srcFolder, "lib");
-    if (!fs22.existsSync(libPath)) {
-      fs22.mkdirSync(libPath, { recursive: true });
-    }
-    const libDestinationPath = path22.join(libPath, "email.ts");
-    fs22.copyFileSync(templatePath, libDestinationPath);
-    console.log(chalk23.green("\nCompleted installation successfully"));
-    console.log(chalk23.cyan("\nInstall Package:"));
+    const libPath = path26.join(projectDir, srcFolder, "lib");
+    if (!fs26.existsSync(libPath)) {
+      fs26.mkdirSync(libPath, { recursive: true });
+    }
+    const libDestinationPath = path26.join(libPath, "email.ts");
+    fs26.copyFileSync(templatePath, libDestinationPath);
+    console.log(chalk27.green("\nCompleted installation successfully"));
+    console.log(chalk27.cyan("\nInstall Package:"));
     console.log(
-      chalk23.white(
+      chalk27.white(
         `\u2022 nodemailer
 \u2022 @react-email/components
 \u2022 @react-email/render`
       )
     );
-    console.log(chalk23.cyan("\nFiles created:"));
+    console.log(chalk27.cyan("\nFiles created:"));
     console.log(
-      chalk23.white(
+      chalk27.white(
         `${CreateFolder({ srcFolder, destFolder: "lib/email.ts" })}
 `
       )
     );
   } catch (error) {
-    console.log(chalk23.red(error));
+    console.log(chalk27.red(error));
   }
 };
 
 // email/awsSesRunTanstackStart.ts
-import chalk24 from "chalk";
-import path23 from "path";
-import fs23 from "fs";
-import { fileURLToPath as fileURLToPath22 } from "url";
+import chalk28 from "chalk";
+import path27 from "path";
+import fs27 from "fs";
+import { fileURLToPath as fileURLToPath24 } from "url";
 var awsSesRunTanstackStart = async () => {
   try {
     const projectDir = process.cwd();
-    const packageJsonPath = path23.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(fs23.readFileSync(packageJsonPath, "utf-8"));
-    const __filename = fileURLToPath22(import.meta.url);
-    const __dirname = path23.dirname(__filename);
+    const packageJsonPath = path27.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(fs27.readFileSync(packageJsonPath, "utf-8"));
+    const __filename = fileURLToPath24(import.meta.url);
+    const __dirname = path27.dirname(__filename);
     if (!packageJson2.dependencies?.nodemailer || !packageJson2.devDependencies?.["@types/nodemailer"]) {
-      console.log(chalk24.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
+      console.log(chalk28.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
       packageManager("nodemailer");
       packageManager("@types/nodemailer", true);
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(chalk24.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      console.log(chalk28.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
       packageManager("@react-email/components");
     }
     if (!packageJson2.dependencies?.["@react-email/render"]) {
-      console.log(chalk24.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
+      console.log(chalk28.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
       packageManager("@react-email/render");
     }
-    const envPath = path23.join(projectDir, ".env");
-    const envContent = fs23.readFileSync(envPath, "utf8");
-    if (!envContent.includes("AWS_SES_HOST") && !envContent.includes("AWS_SES_PORT") && !envContent.includes("AWS_SES_SERVICE") && !envContent.includes("AWS_SES_USER") && !envContent.includes("AWS_SES_PASS") && !envContent.includes("AWS_SES_FROM")) {
-      fs23.appendFileSync(envPath, `
+    const envPath = path27.join(projectDir, ".env");
+    const envContent = fs27.readFileSync(envPath, "utf8");
+    if (!envContent.includes("AWS_SES_HOST") && !envContent.includes("AWS_SES_PORT") && !envContent.includes("AWS_SES_SERVICE") && !envContent.includes("AWS_SES_USER") && !envContent.includes("AWS_SES_PASS") && !envContent.includes("AWS_SES_FROM") && !envContent.includes("AWS_SES_FROM_NAME")) {
+      fs27.appendFileSync(envPath, `
 
 # AWS SES API Key for sending emails`);
-      fs23.appendFileSync(envPath, `
+      fs27.appendFileSync(envPath, `
 AWS_SES_HOST=`);
-      fs23.appendFileSync(envPath, `
+      fs27.appendFileSync(envPath, `
 AWS_SES_PORT=`);
-      fs23.appendFileSync(envPath, `
+      fs27.appendFileSync(envPath, `
 AWS_SES_SERVICE=`);
-      fs23.appendFileSync(envPath, `
+      fs27.appendFileSync(envPath, `
 AWS_SES_USER=`);
-      fs23.appendFileSync(envPath, `
+      fs27.appendFileSync(envPath, `
 AWS_SES_PASS=`);
-      fs23.appendFileSync(envPath, `
+      fs27.appendFileSync(envPath, `
 AWS_SES_FROM=`);
+      fs27.appendFileSync(envPath, `
+AWS_SES_FROM_NAME=`);
     }
-    const templatePath = path23.resolve(
+    const templatePath = path27.resolve(
       __dirname,
       "./template/email/emailAwsSes.ts"
     );
-    const libPath = path23.join(projectDir, "src", "lib");
-    if (!fs23.existsSync(libPath)) {
-      fs23.mkdirSync(libPath, { recursive: true });
-    }
-    const libDestinationPath = path23.join(libPath, "email.ts");
-    fs23.copyFileSync(templatePath, libDestinationPath);
-    console.log(chalk24.green("\nCompleted installation successfully"));
-    console.log(chalk24.cyan("\nInstall Package:"));
+    const libPath = path27.join(projectDir, "src", "lib");
+    if (!fs27.existsSync(libPath)) {
+      fs27.mkdirSync(libPath, { recursive: true });
+    }
+    const libDestinationPath = path27.join(libPath, "email.ts");
+    fs27.copyFileSync(templatePath, libDestinationPath);
+    console.log(chalk28.green("\nCompleted installation successfully"));
+    console.log(chalk28.cyan("\nInstall Package:"));
     console.log(
-      chalk24.white(
+      chalk28.white(
         `\u2022 nodemailer
 \u2022 @react-email/components
 \u2022 @react-email/render`
       )
     );
-    console.log(chalk24.cyan("\nFiles created:"));
-    console.log(chalk24.white("\u2022 src/lib/email.ts\n"));
+    console.log(chalk28.cyan("\nFiles created:"));
+    console.log(chalk28.white("\u2022 src/lib/email.ts\n"));
   } catch (error) {
-    console.log(chalk24.red(error));
+    console.log(chalk28.red(error));
   }
 };
 
 // email/resendRun.ts
-import chalk25 from "chalk";
-import path24 from "path";
-import fs24 from "fs";
-import { fileURLToPath as fileURLToPath23 } from "url";
+import chalk29 from "chalk";
+import path28 from "path";
+import fs28 from "fs";
+import { fileURLToPath as fileURLToPath25 } from "url";
 var resendRun = async () => {
   try {
     const projectDir = process.cwd();
-    const packageJsonPath = path24.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(fs24.readFileSync(packageJsonPath, "utf-8"));
-    const srcFolder = fs24.existsSync(path24.join(projectDir, "src")) ? "src" : "";
-    const __filename = fileURLToPath23(import.meta.url);
-    const __dirname = path24.dirname(__filename);
+    const packageJsonPath = path28.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(fs28.readFileSync(packageJsonPath, "utf-8"));
+    const srcFolder = fs28.existsSync(path28.join(projectDir, "src")) ? "src" : "";
+    const __filename = fileURLToPath25(import.meta.url);
+    const __dirname = path28.dirname(__filename);
     if (!packageJson2.dependencies?.resend) {
-      console.log(chalk25.cyan("\n\u2699\uFE0F Installing Resend...\n"));
+      console.log(chalk29.cyan("\n\u2699\uFE0F Installing Resend...\n"));
       packageManager("resend");
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(chalk25.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      console.log(chalk29.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
       packageManager("@react-email/components");
     }
     if (!packageJson2.dependencies?.["@react-email/render"]) {
-      console.log(chalk25.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
+      console.log(chalk29.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
       packageManager("@react-email/render");
     }
-    const envPath = path24.join(projectDir, ".env");
-    const envContent = fs24.readFileSync(envPath, "utf8");
+    const envPath = path28.join(projectDir, ".env");
+    const envContent = fs28.readFileSync(envPath, "utf8");
     if (!envContent.includes("RESEND_API_KEY") && !envContent.includes("EMAIL_SENDER_NAME") && !envContent.includes("EMAIL_SENDER_ADDRESS")) {
-      fs24.appendFileSync(envPath, `
+      fs28.appendFileSync(envPath, `
 
 # Resend API Key for sending emails`);
-      fs24.appendFileSync(envPath, `
+      fs28.appendFileSync(envPath, `
 RESEND_API_KEY=`);
-      fs24.appendFileSync(envPath, `
+      fs28.appendFileSync(envPath, `
 EMAIL_SENDER_NAME=Your Name`);
-      fs24.appendFileSync(envPath, `
+      fs28.appendFileSync(envPath, `
 EMAIL_SENDER_ADDRESS=`);
     }
-    const templatePath = path24.resolve(
+    const templatePath = path28.resolve(
       __dirname,
       "./template/email/emailResend.ts"
     );
-    const libPath = path24.join(projectDir, srcFolder, "lib");
-    if (!fs24.existsSync(libPath)) {
-      fs24.mkdirSync(libPath, { recursive: true });
-    }
-    const libDestinationPath = path24.join(libPath, "email.ts");
-    fs24.copyFileSync(templatePath, libDestinationPath);
-    console.log(chalk25.green("\nCompleted installation successfully"));
-    console.log(chalk25.cyan("\nInstall Package:"));
+    const libPath = path28.join(projectDir, srcFolder, "lib");
+    if (!fs28.existsSync(libPath)) {
+      fs28.mkdirSync(libPath, { recursive: true });
+    }
+    const libDestinationPath = path28.join(libPath, "email.ts");
+    fs28.copyFileSync(templatePath, libDestinationPath);
+    console.log(chalk29.green("\nCompleted installation successfully"));
+    console.log(chalk29.cyan("\nInstall Package:"));
     console.log(
-      chalk25.white(`\u2022 resend
+      chalk29.white(`\u2022 resend
 \u2022 @react-email/components
 \u2022 @react-email/render`)
     );
-    console.log(chalk25.cyan("\nFiles created:"));
+    console.log(chalk29.cyan("\nFiles created:"));
     console.log(
-      chalk25.white(
+      chalk29.white(
         `${CreateFolder({ srcFolder, destFolder: "lib/email.ts" })}
 `
       )
     );
   } catch (error) {
-    console.log(chalk25.red(error));
+    console.log(chalk29.red(error));
   }
 };
 
 // email/resendRunTanstackStart.ts
-import chalk26 from "chalk";
-import path25 from "path";
-import fs25 from "fs";
-import { fileURLToPath as fileURLToPath24 } from "url";
+import chalk30 from "chalk";
+import path29 from "path";
+import fs29 from "fs";
+import { fileURLToPath as fileURLToPath26 } from "url";
 var resendRunTanstackStart = async () => {
   try {
     const projectDir = process.cwd();
-    const packageJsonPath = path25.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(fs25.readFileSync(packageJsonPath, "utf-8"));
-    const __filename = fileURLToPath24(import.meta.url);
-    const __dirname = path25.dirname(__filename);
+    const packageJsonPath = path29.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(fs29.readFileSync(packageJsonPath, "utf-8"));
+    const __filename = fileURLToPath26(import.meta.url);
+    const __dirname = path29.dirname(__filename);
     if (!packageJson2.dependencies?.resend) {
-      console.log(chalk26.cyan("\n\u2699\uFE0F Installing Resend...\n"));
+      console.log(chalk30.cyan("\n\u2699\uFE0F Installing Resend...\n"));
       packageManager("resend");
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(chalk26.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      console.log(chalk30.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
       packageManager("@react-email/components");
     }
-    const envPath = path25.join(projectDir, ".env");
-    const envContent = fs25.readFileSync(envPath, "utf8");
+    const envPath = path29.join(projectDir, ".env");
+    const envContent = fs29.readFileSync(envPath, "utf8");
     if (!envContent.includes("RESEND_API_KEY") && !envContent.includes("EMAIL_SENDER_NAME") && !envContent.includes("EMAIL_SENDER_ADDRESS")) {
-      fs25.appendFileSync(envPath, `
+      fs29.appendFileSync(envPath, `
 
 # Resend API Key for sending emails`);
-      fs25.appendFileSync(envPath, `
+      fs29.appendFileSync(envPath, `
 RESEND_API_KEY=`);
-      fs25.appendFileSync(envPath, `
+      fs29.appendFileSync(envPath, `
 EMAIL_SENDER_NAME=Your Name`);
-      fs25.appendFileSync(envPath, `
+      fs29.appendFileSync(envPath, `
 EMAIL_SENDER_ADDRESS=`);
     }
-    const templatePath = path25.resolve(
+    const templatePath = path29.resolve(
       __dirname,
       "./template/email/emailResend.ts"
     );
-    const libPath = path25.join(projectDir, "src", "lib");
-    if (!fs25.existsSync(libPath)) {
-      fs25.mkdirSync(libPath, { recursive: true });
-    }
-    const libDestinationPath = path25.join(libPath, "email.ts");
-    fs25.copyFileSync(templatePath, libDestinationPath);
-    console.log(chalk26.green("\nCompleted installation successfully"));
-    console.log(chalk26.cyan("\nInstall Package:"));
+    const libPath = path29.join(projectDir, "src", "lib");
+    if (!fs29.existsSync(libPath)) {
+      fs29.mkdirSync(libPath, { recursive: true });
+    }
+    const libDestinationPath = path29.join(libPath, "email.ts");
+    fs29.copyFileSync(templatePath, libDestinationPath);
+    console.log(chalk30.green("\nCompleted installation successfully"));
+    console.log(chalk30.cyan("\nInstall Package:"));
     console.log(
-      chalk26.white(`\u2022 resend
+      chalk30.white(`\u2022 resend
 \u2022 @react-email/components
 \u2022 @react-email/render`)
     );
-    console.log(chalk26.cyan("\nFiles created:"));
-    console.log(chalk26.white("\u2022 src/lib/email.ts\n"));
+    console.log(chalk30.cyan("\nFiles created:"));
+    console.log(chalk30.white("\u2022 src/lib/email.ts\n"));
   } catch (error) {
-    console.log(chalk26.red(error));
+    console.log(chalk30.red(error));
   }
 };
 
 // cli/email.ts
-import chalk27 from "chalk";
+import chalk31 from "chalk";
 var email = async () => {
   const projectDir = process.cwd();
   const { framework, error } = await getFramework();
   if (error) {
-    console.log(chalk27.red(error));
+    console.log(chalk31.red(error));
     return;
   }
   if (framework === "Next js") {
-    const srcFolder = fs26.existsSync(path26.join(projectDir, "src")) ? "src" : "";
-    const emailPath = path26.join(projectDir, srcFolder, "lib", "email.ts");
-    if (fs26.existsSync(emailPath)) {
-      const answers2 = await inquirer4.prompt([
+    const srcFolder = fs30.existsSync(path30.join(projectDir, "src")) ? "src" : "";
+    const emailPath = path30.join(projectDir, srcFolder, "lib", "email.ts");
+    if (fs30.existsSync(emailPath)) {
+      const answers2 = await inquirer5.prompt([
         {
           type: "confirm",
           name: "overwrite",
@@ -2975,13 +3514,13 @@ var email = async () => {
     }
   }
   if (framework === "tanstack start") {
-    const srcFolderTanstackState = path26.join(projectDir, "src");
-    const libPathTanstackState = path26.join(
+    const srcFolderTanstackState = path30.join(projectDir, "src");
+    const libPathTanstackState = path30.join(
       srcFolderTanstackState,
       "lib/email.ts"
     );
-    if (fs26.existsSync(libPathTanstackState)) {
-      const answers2 = await inquirer4.prompt([
+    if (fs30.existsSync(libPathTanstackState)) {
+      const answers2 = await inquirer5.prompt([
         {
           type: "confirm",
           name: "overwrite",
@@ -2994,9 +3533,9 @@ var email = async () => {
       }
     }
   }
-  const answers = await inquirer4.prompt([
+  const answers = await inquirer5.prompt([
     {
-      type: "list",
+      type: "select",
       name: "emailProvider",
       message: "Choose Your Email Provider:",
       choices: ["Gmail", "AWS SES", "Resend"]
@@ -3026,20 +3565,20 @@ var email = async () => {
 var forgetNext = async () => {
   try {
     const projectDir = process.cwd();
-    const __filename = fileURLToPath25(import.meta.url);
-    const __dirname = path27.dirname(__filename);
-    const srcPath = path27.join(projectDir, "src");
-    const folder = fs27.existsSync(srcPath) ? "src" : "";
-    const emailFilePath = path27.join(projectDir, folder, "lib", "email.ts");
-    if (!fs27.existsSync(emailFilePath)) {
+    const __filename = fileURLToPath27(import.meta.url);
+    const __dirname = path31.dirname(__filename);
+    const srcPath = path31.join(projectDir, "src");
+    const folder = fs31.existsSync(srcPath) ? "src" : "";
+    const emailFilePath = path31.join(projectDir, folder, "lib", "email.ts");
+    if (!fs31.existsSync(emailFilePath)) {
       await email();
     }
-    const authFilePath = path27.join(projectDir, folder, "lib", "auth.ts");
-    if (!fs27.existsSync(authFilePath)) {
-      console.log(chalk28.red("auth.ts file not found."));
+    const authFilePath = path31.join(projectDir, folder, "lib", "auth.ts");
+    if (!fs31.existsSync(authFilePath)) {
+      console.log(chalk32.red("auth.ts file not found."));
       return;
     }
-    let content = fs27.readFileSync(authFilePath, "utf8");
+    let content = fs31.readFileSync(authFilePath, "utf8");
     const codeAdded = `sendResetPassword: async ({ user, url, token }) => {
       await sendEmail({
         email: user.email!,
@@ -3077,7 +3616,7 @@ var forgetNext = async () => {
         const after = content.substring(emailAndPasswordEnd);
         content = before + `${codeAdded}` + after;
       }
-      fs27.writeFileSync(authFilePath, content, "utf8");
+      fs31.writeFileSync(authFilePath, content, "utf8");
       if (!content.includes("import { sendEmail }")) {
         const lastImportIndex = content.lastIndexOf("import");
         const nextLineAfterLastImport = content.indexOf("\n", lastImportIndex) + 1;
@@ -3086,7 +3625,7 @@ var forgetNext = async () => {
         const newImports = `import { sendEmail } from "./email";
 `;
         content = beforeImports + newImports + afterImports;
-        fs27.writeFileSync(authFilePath, content, "utf8");
+        fs31.writeFileSync(authFilePath, content, "utf8");
       }
       if (!content.includes("import ForgotPasswordEmail from")) {
         const lastImportIndex = content.lastIndexOf("import");
@@ -3096,97 +3635,97 @@ var forgetNext = async () => {
         const newImports = `import ForgotPasswordEmail from "@/components/email/reset-password";
 `;
         content = beforeImports + newImports + afterImports;
-        fs27.writeFileSync(authFilePath, content, "utf8");
+        fs31.writeFileSync(authFilePath, content, "utf8");
       }
-      const componentPath = path27.resolve(
+      const componentPath = path31.resolve(
         __dirname,
         "./template/email/reset-password.tsx"
       );
-      const destinationPath = path27.join(
+      const destinationPath = path31.join(
         projectDir,
         folder,
         "components",
         "email"
       );
-      if (!fs27.existsSync(destinationPath)) {
-        fs27.mkdirSync(destinationPath, { recursive: true });
+      if (!fs31.existsSync(destinationPath)) {
+        fs31.mkdirSync(destinationPath, { recursive: true });
       }
-      const emailDestinationPath = path27.join(
+      const emailDestinationPath = path31.join(
         destinationPath,
         "reset-password.tsx"
       );
-      if (fs27.existsSync(componentPath)) {
-        fs27.copyFileSync(componentPath, emailDestinationPath);
+      if (fs31.existsSync(componentPath)) {
+        fs31.copyFileSync(componentPath, emailDestinationPath);
       }
-      const forgetComponentPath = path27.resolve(
+      const forgetComponentPath = path31.resolve(
         __dirname,
         "./template/components/ForgetComponent.tsx"
       );
-      const componentsDestinationPath = path27.join(
+      const componentsDestinationPath = path31.join(
         projectDir,
         folder,
         "components",
         "authverse"
       );
-      if (!fs27.existsSync(componentsDestinationPath)) {
-        fs27.mkdirSync(componentsDestinationPath, { recursive: true });
+      if (!fs31.existsSync(componentsDestinationPath)) {
+        fs31.mkdirSync(componentsDestinationPath, { recursive: true });
       }
-      const forgetDestinationPath = path27.join(
+      const forgetDestinationPath = path31.join(
         componentsDestinationPath,
         "ForgetComponent.tsx"
       );
-      if (fs27.existsSync(forgetComponentPath)) {
-        fs27.copyFileSync(forgetComponentPath, forgetDestinationPath);
+      if (fs31.existsSync(forgetComponentPath)) {
+        fs31.copyFileSync(forgetComponentPath, forgetDestinationPath);
       }
-      const resetComponentPath = path27.resolve(
+      const resetComponentPath = path31.resolve(
         __dirname,
         "./template/components/ResetComponent.tsx"
       );
-      const resetDestinationPath = path27.join(
+      const resetDestinationPath = path31.join(
         componentsDestinationPath,
         "ResetComponent.tsx"
       );
-      if (fs27.existsSync(resetComponentPath)) {
-        fs27.copyFileSync(resetComponentPath, resetDestinationPath);
+      if (fs31.existsSync(resetComponentPath)) {
+        fs31.copyFileSync(resetComponentPath, resetDestinationPath);
       }
-      const authTemplatePath = path27.resolve(
+      const authTemplatePath = path31.resolve(
         __dirname,
         "./template/app-auth-uiDesign"
       );
-      const appDestinationPath = path27.join(projectDir, folder, "app", "auth");
-      if (!fs27.existsSync(appDestinationPath)) {
-        fs27.mkdirSync(appDestinationPath, { recursive: true });
+      const appDestinationPath = path31.join(projectDir, folder, "app", "auth");
+      if (!fs31.existsSync(appDestinationPath)) {
+        fs31.mkdirSync(appDestinationPath, { recursive: true });
       }
-      const forgetDestinationDir = path27.join(appDestinationPath, "forget");
-      if (!fs27.existsSync(forgetDestinationDir)) {
-        fs27.mkdirSync(forgetDestinationDir, { recursive: true });
+      const forgetDestinationDir = path31.join(appDestinationPath, "forget");
+      if (!fs31.existsSync(forgetDestinationDir)) {
+        fs31.mkdirSync(forgetDestinationDir, { recursive: true });
       }
-      const forgetPageDestinationPath = path27.join(
+      const forgetPageDestinationPath = path31.join(
         forgetDestinationDir,
         "page.tsx"
       );
-      fs27.copyFileSync(
+      fs31.copyFileSync(
         `${authTemplatePath}/forget/page.tsx`,
         forgetPageDestinationPath
       );
-      const resetDestinationDir = path27.join(
+      const resetDestinationDir = path31.join(
         appDestinationPath,
         "reset-password"
       );
-      if (!fs27.existsSync(resetDestinationDir)) {
-        fs27.mkdirSync(resetDestinationDir, { recursive: true });
+      if (!fs31.existsSync(resetDestinationDir)) {
+        fs31.mkdirSync(resetDestinationDir, { recursive: true });
       }
-      const resetPageDestinationPath = path27.join(
+      const resetPageDestinationPath = path31.join(
         resetDestinationDir,
         "page.tsx"
       );
-      fs27.copyFileSync(
+      fs31.copyFileSync(
         `${authTemplatePath}/reset-password/page.tsx`,
         resetPageDestinationPath
       );
-      console.log(chalk28.green("\nCompleted installation successfully"));
+      console.log(chalk32.green("\nCompleted installation successfully"));
       console.log(
-        chalk28.white(
+        chalk32.white(
           `${CreateFolder({ srcFolder: folder, destFolder: "components/authverse/ForgetComponent.tsx" })}
 ${CreateFolder({ srcFolder: folder, destFolder: "components/authverse/ResetComponent.tsx" })}
 ${CreateFolder({ srcFolder: folder, destFolder: "components/email/reset-password.tsx" })}
@@ -3197,35 +3736,35 @@ ${CreateFolder({ srcFolder: folder, destFolder: "app/auth/reset-password/page.ts
       );
     } else {
       console.log(
-        chalk28.red("Could not find emailAndPassword configuration in auth.ts")
+        chalk32.red("Could not find emailAndPassword configuration in auth.ts")
       );
     }
   } catch (error) {
-    console.log(chalk28.red("Error adding sendResetPassword:"), error);
+    console.log(chalk32.red("Error adding sendResetPassword:"), error);
   }
 };
 
 // script/forgetTanstack.ts
-import chalk29 from "chalk";
-import path28 from "path";
-import { fileURLToPath as fileURLToPath26 } from "url";
-import fs28 from "fs";
+import chalk33 from "chalk";
+import path32 from "path";
+import { fileURLToPath as fileURLToPath28 } from "url";
+import fs32 from "fs";
 var forgetTanstack = async () => {
   try {
     const projectDir = process.cwd();
-    const __filename = fileURLToPath26(import.meta.url);
-    const __dirname = path28.dirname(__filename);
-    const srcPath = path28.join(projectDir, "src");
-    const emailFilePath = path28.join(srcPath, "lib", "email.ts");
-    if (!fs28.existsSync(emailFilePath)) {
+    const __filename = fileURLToPath28(import.meta.url);
+    const __dirname = path32.dirname(__filename);
+    const srcPath = path32.join(projectDir, "src");
+    const emailFilePath = path32.join(srcPath, "lib", "email.ts");
+    if (!fs32.existsSync(emailFilePath)) {
       await email();
     }
-    const authFilePath = path28.join(srcPath, "lib", "auth.ts");
-    if (!fs28.existsSync(authFilePath)) {
-      console.log(chalk29.red("auth.ts file not found."));
+    const authFilePath = path32.join(srcPath, "lib", "auth.ts");
+    if (!fs32.existsSync(authFilePath)) {
+      console.log(chalk33.red("auth.ts file not found."));
       return;
     }
-    let content = fs28.readFileSync(authFilePath, "utf8");
+    let content = fs32.readFileSync(authFilePath, "utf8");
     const codeAdded = `sendResetPassword: async ({ user, url, token }) => {
       await sendEmail({
         email: user.email!,
@@ -3263,7 +3802,7 @@ var forgetTanstack = async () => {
         const after = content.substring(emailAndPasswordEnd);
         content = before + `${codeAdded}` + after;
       }
-      fs28.writeFileSync(authFilePath, content, "utf8");
+      fs32.writeFileSync(authFilePath, content, "utf8");
       if (!content.includes("import { sendEmail }")) {
         const lastImportIndex = content.lastIndexOf("import");
         const nextLineAfterLastImport = content.indexOf("\n", lastImportIndex) + 1;
@@ -3272,7 +3811,7 @@ var forgetTanstack = async () => {
         const newImports = `import { sendEmail } from "./email";
 `;
         content = beforeImports + newImports + afterImports;
-        fs28.writeFileSync(authFilePath, content, "utf8");
+        fs32.writeFileSync(authFilePath, content, "utf8");
       }
       if (!content.includes("import ForgotPasswordEmail from")) {
         const lastImportIndex = content.lastIndexOf("import");
@@ -3282,80 +3821,80 @@ var forgetTanstack = async () => {
         const newImports = `import ForgotPasswordEmail from "@/components/email/reset-password";
 `;
         content = beforeImports + newImports + afterImports;
-        fs28.writeFileSync(authFilePath, content, "utf8");
+        fs32.writeFileSync(authFilePath, content, "utf8");
       }
-      const componentPath = path28.resolve(
+      const componentPath = path32.resolve(
         __dirname,
         "./template/email/reset-password.tsx"
       );
-      const destinationPath = path28.join(srcPath, "components", "email");
-      if (!fs28.existsSync(destinationPath)) {
-        fs28.mkdirSync(destinationPath, { recursive: true });
+      const destinationPath = path32.join(srcPath, "components", "email");
+      if (!fs32.existsSync(destinationPath)) {
+        fs32.mkdirSync(destinationPath, { recursive: true });
       }
-      const emailDestinationPath = path28.join(
+      const emailDestinationPath = path32.join(
         destinationPath,
         "reset-password.tsx"
       );
-      if (fs28.existsSync(componentPath)) {
-        fs28.copyFileSync(componentPath, emailDestinationPath);
+      if (fs32.existsSync(componentPath)) {
+        fs32.copyFileSync(componentPath, emailDestinationPath);
       }
-      const forgetComponentPath = path28.resolve(
+      const forgetComponentPath = path32.resolve(
         __dirname,
         "./template/TanstackStart/components/ForgetComponent.tsx"
       );
-      const componentsDestinationPath = path28.join(
+      const componentsDestinationPath = path32.join(
         srcPath,
         "components",
         "authverse"
       );
-      if (!fs28.existsSync(componentsDestinationPath)) {
-        fs28.mkdirSync(componentsDestinationPath, { recursive: true });
+      if (!fs32.existsSync(componentsDestinationPath)) {
+        fs32.mkdirSync(componentsDestinationPath, { recursive: true });
       }
-      const forgetDestinationPath = path28.join(
+      const forgetDestinationPath = path32.join(
         componentsDestinationPath,
         "ForgetComponent.tsx"
       );
-      if (fs28.existsSync(forgetComponentPath)) {
-        fs28.copyFileSync(forgetComponentPath, forgetDestinationPath);
+      if (fs32.existsSync(forgetComponentPath)) {
+        fs32.copyFileSync(forgetComponentPath, forgetDestinationPath);
       }
-      const resetComponentPath = path28.resolve(
+      const resetComponentPath = path32.resolve(
         __dirname,
         "./template/TanstackStart/components/ResetComponent.tsx"
       );
-      const resetDestinationPath = path28.join(
+      const resetDestinationPath = path32.join(
         componentsDestinationPath,
         "ResetComponent.tsx"
       );
-      if (fs28.existsSync(resetComponentPath)) {
-        fs28.copyFileSync(resetComponentPath, resetDestinationPath);
+      if (fs32.existsSync(resetComponentPath)) {
+        fs32.copyFileSync(resetComponentPath, resetDestinationPath);
       }
-      const authTemplatePath = path28.resolve(
+      const authTemplatePath = path32.resolve(
         __dirname,
         "./template/TanstackStart/routes/auth"
       );
-      const routesDestinationPath = path28.join(srcPath, "routes", "auth");
-      if (!fs28.existsSync(routesDestinationPath)) {
-        fs28.mkdirSync(routesDestinationPath, { recursive: true });
+      const routesDestinationPath = path32.join(srcPath, "routes", "auth");
+      if (!fs32.existsSync(routesDestinationPath)) {
+        fs32.mkdirSync(routesDestinationPath, { recursive: true });
       }
-      const forgetPageDestinationPath = path28.join(
+      const forgetPageDestinationPath = path32.join(
         routesDestinationPath,
         "forget.tsx"
       );
-      fs28.copyFileSync(
+      fs32.copyFileSync(
         `${authTemplatePath}/forget.tsx`,
         forgetPageDestinationPath
       );
-      const resetPageDestinationPath = path28.join(
+      const resetPageDestinationPath = path32.join(
         routesDestinationPath,
         "reset-password.tsx"
       );
-      fs28.copyFileSync(
+      fs32.copyFileSync(
         `${authTemplatePath}/reset-password.tsx`,
         resetPageDestinationPath
       );
-      console.log(chalk29.green("\nCompleted installation successfully"));
+      console.log(chalk33.green("\nCompleted installation successfully"));
       console.log(
-        chalk29.white(
+        chalk33.white(
           `\u2022 src/components/authverse/ForgetComponent.tsx
 \u2022 src/components/authverse/ResetComponent.tsx
 \u2022 src/components/email/reset-password.tsx
@@ -3366,20 +3905,20 @@ var forgetTanstack = async () => {
       );
     } else {
       console.log(
-        chalk29.red("Could not find emailAndPassword configuration in auth.ts")
+        chalk33.red("Could not find emailAndPassword configuration in auth.ts")
       );
     }
   } catch (error) {
-    console.log(chalk29.red("Error adding sendResetPassword:"), error);
+    console.log(chalk33.red("Error adding sendResetPassword:"), error);
   }
 };
 
 // cli/forget.ts
-import chalk30 from "chalk";
+import chalk34 from "chalk";
 var forget = async () => {
   const { framework, error } = await getFramework();
   if (error) {
-    console.log(chalk30.red(error));
+    console.log(chalk34.red(error));
     return;
   }
   if (framework === "Next js") {
@@ -3391,30 +3930,30 @@ var forget = async () => {
 };
 
 // cli/verification.ts
-import chalk33 from "chalk";
+import chalk37 from "chalk";
 
 // script/verifyNext.ts
-import chalk31 from "chalk";
-import fs29 from "fs";
-import path29 from "path";
-import { fileURLToPath as fileURLToPath27 } from "url";
+import chalk35 from "chalk";
+import fs33 from "fs";
+import path33 from "path";
+import { fileURLToPath as fileURLToPath29 } from "url";
 var verifyNext = async () => {
   try {
     const projectDir = process.cwd();
-    const __filename = fileURLToPath27(import.meta.url);
-    const __dirname = path29.dirname(__filename);
-    const srcPath = path29.join(projectDir, "src");
-    const folder = fs29.existsSync(srcPath) ? "src" : "";
-    const emailFilePath = path29.join(projectDir, folder, "lib", "email.ts");
-    if (!fs29.existsSync(emailFilePath)) {
+    const __filename = fileURLToPath29(import.meta.url);
+    const __dirname = path33.dirname(__filename);
+    const srcPath = path33.join(projectDir, "src");
+    const folder = fs33.existsSync(srcPath) ? "src" : "";
+    const emailFilePath = path33.join(projectDir, folder, "lib", "email.ts");
+    if (!fs33.existsSync(emailFilePath)) {
       await email();
     }
-    const authFilePath = path29.join(projectDir, folder, "lib", "auth.ts");
-    if (!fs29.existsSync(authFilePath)) {
-      console.log(chalk31.red("auth.ts file not found."));
+    const authFilePath = path33.join(projectDir, folder, "lib", "auth.ts");
+    if (!fs33.existsSync(authFilePath)) {
+      console.log(chalk35.red("auth.ts file not found."));
       return;
     }
-    let content = fs29.readFileSync(authFilePath, "utf8");
+    let content = fs33.readFileSync(authFilePath, "utf8");
     if (content.includes("emailAndPassword: {")) {
       const start = content.indexOf("emailAndPassword: {");
       let end = start;
@@ -3474,51 +4013,51 @@ var verifyNext = async () => {
 `;
       content = content.slice(0, nextLine) + imports + content.slice(nextLine);
     }
-    fs29.writeFileSync(authFilePath, content, "utf8");
-    const templatePath = path29.resolve(
+    fs33.writeFileSync(authFilePath, content, "utf8");
+    const templatePath = path33.resolve(
       __dirname,
       "./template/email/EmailVerification.tsx"
     );
-    const componentsDir = path29.join(projectDir, folder, "components", "email");
-    if (!fs29.existsSync(componentsDir)) {
-      fs29.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = path33.join(projectDir, folder, "components", "email");
+    if (!fs33.existsSync(componentsDir)) {
+      fs33.mkdirSync(componentsDir, { recursive: true });
     }
-    const destFile = path29.join(componentsDir, "EmailVerification.tsx");
-    if (fs29.existsSync(templatePath) && !fs29.existsSync(destFile)) {
-      fs29.copyFileSync(templatePath, destFile);
+    const destFile = path33.join(componentsDir, "EmailVerification.tsx");
+    if (fs33.existsSync(templatePath) && !fs33.existsSync(destFile)) {
+      fs33.copyFileSync(templatePath, destFile);
     }
-    console.log(chalk31.green("\nCompleted installation successfully"));
+    console.log(chalk35.green("\nCompleted installation successfully"));
     console.log(
-      chalk31.white(
+      chalk35.white(
         `${CreateFolder({ srcFolder: folder, destFolder: "components/email/EmailVerification.tsx" })}`
       )
     );
   } catch (error) {
-    console.log(chalk31.red(String(error)));
+    console.log(chalk35.red(String(error)));
   }
 };
 
 // script/verifyTanstack.ts
-import chalk32 from "chalk";
-import fs30 from "fs";
-import path30 from "path";
-import { fileURLToPath as fileURLToPath28 } from "url";
+import chalk36 from "chalk";
+import fs34 from "fs";
+import path34 from "path";
+import { fileURLToPath as fileURLToPath30 } from "url";
 var verifyTanstack = async () => {
   try {
     const projectDir = process.cwd();
-    const __filename = fileURLToPath28(import.meta.url);
-    const __dirname = path30.dirname(__filename);
-    const srcPath = path30.join(projectDir, "src");
-    const emailFilePath = path30.join(srcPath, "lib", "email.ts");
-    if (!fs30.existsSync(emailFilePath)) {
+    const __filename = fileURLToPath30(import.meta.url);
+    const __dirname = path34.dirname(__filename);
+    const srcPath = path34.join(projectDir, "src");
+    const emailFilePath = path34.join(srcPath, "lib", "email.ts");
+    if (!fs34.existsSync(emailFilePath)) {
       await email();
     }
-    const authFilePath = path30.join(srcPath, "lib", "auth.ts");
-    if (!fs30.existsSync(authFilePath)) {
-      console.log(chalk32.red("auth.ts file not found."));
+    const authFilePath = path34.join(srcPath, "lib", "auth.ts");
+    if (!fs34.existsSync(authFilePath)) {
+      console.log(chalk36.red("auth.ts file not found."));
       return;
     }
-    let content = fs30.readFileSync(authFilePath, "utf8");
+    let content = fs34.readFileSync(authFilePath, "utf8");
     if (content.includes("emailAndPassword: {")) {
       const start = content.indexOf("emailAndPassword: {");
       let end = start;
@@ -3578,23 +4117,23 @@ var verifyTanstack = async () => {
 `;
       content = content.slice(0, nextLine) + imports + content.slice(nextLine);
     }
-    fs30.writeFileSync(authFilePath, content, "utf8");
-    const templatePath = path30.resolve(
+    fs34.writeFileSync(authFilePath, content, "utf8");
+    const templatePath = path34.resolve(
       __dirname,
       "./template/email/EmailVerification.tsx"
     );
-    const componentsDir = path30.join(srcPath, "components", "email");
-    if (!fs30.existsSync(componentsDir)) {
-      fs30.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = path34.join(srcPath, "components", "email");
+    if (!fs34.existsSync(componentsDir)) {
+      fs34.mkdirSync(componentsDir, { recursive: true });
     }
-    const destFile = path30.join(componentsDir, "EmailVerification.tsx");
-    if (fs30.existsSync(templatePath) && !fs30.existsSync(destFile)) {
-      fs30.copyFileSync(templatePath, destFile);
+    const destFile = path34.join(componentsDir, "EmailVerification.tsx");
+    if (fs34.existsSync(templatePath) && !fs34.existsSync(destFile)) {
+      fs34.copyFileSync(templatePath, destFile);
     }
-    console.log(chalk32.green("\nCompleted installation successfully"));
-    console.log(chalk32.white(`\u2022 src/components/email/EmailVerification.tsx`));
+    console.log(chalk36.green("\nCompleted installation successfully"));
+    console.log(chalk36.white(`\u2022 src/components/email/EmailVerification.tsx`));
   } catch (error) {
-    console.log(chalk32.red(String(error)));
+    console.log(chalk36.red(String(error)));
   }
 };
 
@@ -3603,7 +4142,7 @@ var verification = async () => {
   try {
     const { framework, error } = await getFramework();
     if (error) {
-      console.log(chalk33.red(error));
+      console.log(chalk37.red(error));
       return;
     }
     if (framework === "Next js") {
@@ -3613,17 +4152,17 @@ var verification = async () => {
       await verifyTanstack();
     }
   } catch (error) {
-    console.log(chalk33.red(error.message));
+    console.log(chalk37.red(error.message));
   }
 };
 
 // cli/initCmd.ts
-import chalk34 from "chalk";
+import chalk38 from "chalk";
 var initCmd = async (cmd) => {
   try {
     const { framework, error } = await getFramework();
     if (error) {
-      console.log(chalk34.red(error));
+      console.log(chalk38.red(error));
       return;
     }
     if (framework === "Next js" && cmd.orm === "prisma") {
@@ -3653,7 +4192,7 @@ var initCmd = async (cmd) => {
       });
     }
   } catch (error) {
-    console.log(chalk34.red(error));
+    console.log(chalk38.red(error));
   }
 };