authverse 1.1.9 → 1.1.10

package/dist/index.cjs

@@ -26,7 +26,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var import_commander = require("commander");
 
 // cli/init.ts
-var import_inquirer3 = __toESM(require("inquirer"), 1);
+var import_inquirer4 = __toESM(require("inquirer"), 1);
 
 // script/prisma.ts
 var import_url2 = require("url");
@@ -447,25 +447,41 @@ ${CreateFolder({ srcFolder, destFolder: "proxy.ts" })}
 };
 
 // script/drizzleRun.ts
+var import_chalk5 = __toESM(require("chalk"), 1);
+var import_path5 = __toESM(require("path"), 1);
+var import_fs5 = __toESM(require("fs"), 1);
+
+// drizzle/drizzleNextSetup.ts
 var import_chalk3 = __toESM(require("chalk"), 1);
 var import_path3 = __toESM(require("path"), 1);
-var import_url3 = require("url");
 var import_fs3 = __toESM(require("fs"), 1);
+var import_url3 = require("url");
 var import_inquirer2 = __toESM(require("inquirer"), 1);
 var import_meta3 = {};
-var drizzleRun = async ({ authUi, cmd }) => {
+var drizzleNextSetup = async ({
+  authUi,
+  cmd,
+  projectDir
+}) => {
   try {
-    const projectDir = process.cwd();
     const packageJsonPath = import_path3.default.join(projectDir, "package.json");
     const packageJson2 = JSON.parse(import_fs3.default.readFileSync(packageJsonPath, "utf-8"));
     if (!packageJson2.dependencies["better-auth"]) {
       console.log(import_chalk3.default.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(import_chalk3.default.cyan("\n\u2699\uFE0F  Initializing drizzle...\n"));
-      packageManager("drizzle-orm @neondatabase/serverless dotenv");
-      packageManager("drizzle-kit", true);
+      packageManager(missingDrizzleDeps.join(" "));
     }
     const __filename = (0, import_url3.fileURLToPath)(import_meta3.url);
     const __dirname = import_path3.default.dirname(__filename);
@@ -623,23 +639,318 @@ ${CreateFolder({ srcFolder, destFolder: "proxy.ts" })}
         )
       );
     }
+  } catch (error) {
+    console.error(import_chalk3.default.red("Drizzle setup failed:"), error);
+  }
+};
+
+// drizzle/drizzleNextChecker.ts
+var import_path4 = __toESM(require("path"), 1);
+var import_chalk4 = __toESM(require("chalk"), 1);
+var import_fs4 = __toESM(require("fs"), 1);
+var import_url4 = require("url");
+var import_inquirer3 = __toESM(require("inquirer"), 1);
+
+// 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 import_meta4 = {};
+var drizzleNextChecker = async ({
+  authUi,
+  cmd,
+  projectDir
+}) => {
+  try {
+    const drizzleConfigPath = import_path4.default.join(projectDir, "drizzle.config.ts");
+    if (!import_fs4.default.existsSync(drizzleConfigPath)) {
+      return await drizzleNextSetup({ authUi, cmd, projectDir });
+    }
+    const drizzleConfigContent = import_fs4.default.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 = (0, import_url4.fileURLToPath)(import_meta4.url);
+    const __dirname = import_path4.default.dirname(__filename);
+    const dbTemplatePath = import_path4.default.resolve(__dirname, "./template/db/schema.ts");
+    const schemaFilePath = import_path4.default.join(projectDir, schemaPath);
+    if (!import_fs4.default.existsSync(schemaFilePath)) {
+      const dbFolder = import_path4.default.dirname(schemaFilePath);
+      if (!import_fs4.default.existsSync(dbFolder)) {
+        import_fs4.default.mkdirSync(dbFolder, { recursive: true });
+      }
+      import_fs4.default.copyFileSync(dbTemplatePath, schemaFilePath);
+    } else {
+      let schemaFileContent = import_fs4.default.readFileSync(schemaFilePath, "utf-8");
+      const dbTemplateContent = import_fs4.default.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}};`
+          );
+        }
+        import_fs4.default.writeFileSync(schemaFilePath, updatedSchemaContent);
+      }
+    }
+    const packageJsonPath = import_path4.default.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(import_fs4.default.readFileSync(packageJsonPath, "utf-8"));
+    if (!packageJson2.dependencies["better-auth"]) {
+      console.log(import_chalk4.default.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(import_chalk4.default.cyan("\n\u2699\uFE0F  Initializing drizzle...\n"));
+      packageManager(missingDrizzleDeps.join(" "));
+    }
+    const envPath = import_path4.default.join(projectDir, ".env");
+    if (!import_fs4.default.existsSync(envPath)) {
+      import_fs4.default.writeFileSync(envPath, "DATABASE_URL=\n");
+    }
+    const secret = await GenerateSecret();
+    const envContent = import_fs4.default.readFileSync(envPath, "utf-8");
+    if (!envContent.includes("BETTER_AUTH_SECRET")) {
+      import_fs4.default.appendFileSync(envPath, `
+
+BETTER_AUTH_SECRET=${secret}`);
+    }
+    if (!envContent.includes("BETTER_AUTH_URL")) {
+      import_fs4.default.appendFileSync(envPath, `
+BETTER_AUTH_URL=http://localhost:3000
+`);
+    }
+    const srcFolder = import_fs4.default.existsSync(import_path4.default.join(projectDir, "src")) ? "src" : "";
+    const libPath = import_path4.default.join(projectDir, srcFolder, "lib");
+    if (!import_fs4.default.existsSync(libPath)) {
+      import_fs4.default.mkdirSync(libPath, { recursive: true });
+    }
+    const authPath = import_path4.default.join(libPath, "auth.ts");
+    const authClientPath = import_path4.default.join(libPath, "auth-client.ts");
+    if (import_fs4.default.existsSync(authPath) || import_fs4.default.existsSync(authClientPath)) {
+      const answers = await import_inquirer3.default.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 = import_path4.default.resolve(
+          __dirname,
+          "./template/lib/auth-drizzle.ts"
+        );
+        const authDestinationPath = import_path4.default.join(libPath, "auth.ts");
+        import_fs4.default.copyFileSync(authTemplatePath, authDestinationPath);
+        const authClientTemplatePath = import_path4.default.resolve(
+          __dirname,
+          "./template/lib/auth-client.ts"
+        );
+        const authClientDestinationPath = import_path4.default.join(libPath, "auth-client.ts");
+        import_fs4.default.copyFileSync(authClientTemplatePath, authClientDestinationPath);
+      }
+    } else {
+      const authTemplatePath = import_path4.default.resolve(
+        __dirname,
+        "./template/lib/auth-drizzle.ts"
+      );
+      const authDestinationPath = import_path4.default.join(libPath, "auth.ts");
+      import_fs4.default.copyFileSync(authTemplatePath, authDestinationPath);
+      const authClientTemplatePath = import_path4.default.resolve(
+        __dirname,
+        "./template/lib/auth-client.ts"
+      );
+      const authClientDestinationPath = import_path4.default.join(libPath, "auth-client.ts");
+      import_fs4.default.copyFileSync(authClientTemplatePath, authClientDestinationPath);
+    }
+    const routeTemplatePath = import_path4.default.resolve(
+      __dirname,
+      "./template/api/route.ts"
+    );
+    const routeDestinationDir = import_path4.default.join(
+      projectDir,
+      srcFolder,
+      "app",
+      "api",
+      "auth",
+      "[...all]"
+    );
+    if (!import_fs4.default.existsSync(routeDestinationDir)) {
+      import_fs4.default.mkdirSync(routeDestinationDir, { recursive: true });
+    }
+    const routeDestinationPath = import_path4.default.join(routeDestinationDir, "route.ts");
+    import_fs4.default.copyFileSync(routeTemplatePath, routeDestinationPath);
+    const proxyTemplatePath = import_path4.default.resolve(
+      __dirname,
+      "./template/proxy/proxy.ts"
+    );
+    const proxyDestinationDir = import_path4.default.join(projectDir, srcFolder);
+    const proxyDestinationPath = import_path4.default.join(proxyDestinationDir, "proxy.ts");
+    import_fs4.default.copyFileSync(proxyTemplatePath, proxyDestinationPath);
+    if (authUi) {
+      await authUiRun({
+        folder: srcFolder,
+        packageJson: projectDir,
+        cmd,
+        database: "drizzle"
+      });
+    } else {
+      console.log(import_chalk4.default.green("\nCompleted installation successfully"));
+      console.log(import_chalk4.default.cyan("\nInstall Package:"));
+      console.log(import_chalk4.default.white(`\u2022 drizzle schema
+\u2022 better-auth`));
+      console.log(import_chalk4.default.cyan("\nFiles created:"));
+      console.log(
+        import_chalk4.default.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(import_chalk4.default.red("Error checking Drizzle setup:"), error);
+  }
+};
+
+// script/drizzleRun.ts
+var drizzleRun = async ({ authUi, cmd }) => {
+  try {
+    const projectDir = process.cwd();
+    const drizzleConfigPath = import_path5.default.join(projectDir, "drizzle.config.ts");
+    if (import_fs5.default.existsSync(drizzleConfigPath)) {
+      await drizzleNextChecker({ authUi, cmd, projectDir });
+    } else {
+      await drizzleNextSetup({ authUi, cmd, projectDir });
+    }
   } catch (err) {
-    console.error(import_chalk3.default.red("Drizzle setup failed:"), err);
+    console.error(import_chalk5.default.red("Drizzle setup failed:"), err);
   }
 };
 
 // script/prismaRunTanstackStart.ts
-var import_chalk5 = __toESM(require("chalk"), 1);
-var import_path5 = __toESM(require("path"), 1);
-var import_url5 = require("url");
-var import_fs5 = __toESM(require("fs"), 1);
+var import_chalk7 = __toESM(require("chalk"), 1);
+var import_path7 = __toESM(require("path"), 1);
+var import_url6 = require("url");
+var import_fs7 = __toESM(require("fs"), 1);
 
 // script/authUiTanstackState.ts
-var import_chalk4 = __toESM(require("chalk"), 1);
-var import_url4 = require("url");
-var import_path4 = __toESM(require("path"), 1);
-var import_fs4 = __toESM(require("fs"), 1);
-var import_meta4 = {};
+var import_chalk6 = __toESM(require("chalk"), 1);
+var import_url5 = require("url");
+var import_path6 = __toESM(require("path"), 1);
+var import_fs6 = __toESM(require("fs"), 1);
+var import_meta5 = {};
 var shadcnComponents2 = [
   "button.tsx",
   "card.tsx",
@@ -656,10 +967,10 @@ var authUiTanstackState = async ({
 }) => {
   try {
     const projectDir = process.cwd();
-    const shadcnPath = import_path4.default.join(projectDir, "src", "components", "ui");
-    const shadcnConfigPath = import_path4.default.join(projectDir, "components.json");
-    if (!import_fs4.default.existsSync(shadcnPath) || !import_fs4.default.existsSync(shadcnConfigPath)) {
-      console.log(import_chalk4.default.yellow("\n Installing shadcn ui Components\n"));
+    const shadcnPath = import_path6.default.join(projectDir, "src", "components", "ui");
+    const shadcnConfigPath = import_path6.default.join(projectDir, "components.json");
+    if (!import_fs6.default.existsSync(shadcnPath) || !import_fs6.default.existsSync(shadcnConfigPath)) {
+      console.log(import_chalk6.default.yellow("\n Installing shadcn ui Components\n"));
       if (cmd == true) {
         runCommand("shadcn@latest init");
         runCommand("shadcn@latest add button sonner card field input");
@@ -667,60 +978,60 @@ var authUiTanstackState = async ({
         runCommand("shadcn@latest add button sonner card field input");
       }
     }
-    const shadcnFiles = import_fs4.default.readdirSync(shadcnPath);
+    const shadcnFiles = import_fs6.default.readdirSync(shadcnPath);
     const missingComponents = shadcnComponents2.filter(
       (component) => !shadcnFiles.includes(component)
     );
     if (missingComponents.length > 0) {
-      console.log(import_chalk4.default.yellow("\n Installing shadcn ui Components\n"));
+      console.log(import_chalk6.default.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 = (0, import_url4.fileURLToPath)(import_meta4.url);
-    const __dirname = import_path4.default.dirname(__filename);
-    const srcPath = import_path4.default.join(projectDir, "src");
-    const componentPath = import_path4.default.resolve(
+    const __filename = (0, import_url5.fileURLToPath)(import_meta5.url);
+    const __dirname = import_path6.default.dirname(__filename);
+    const srcPath = import_path6.default.join(projectDir, "src");
+    const componentPath = import_path6.default.resolve(
       __dirname,
       "./template/TanstackStart/components"
     );
-    const authversePathComponents = import_path4.default.join(
+    const authversePathComponents = import_path6.default.join(
       srcPath,
       "components",
       "authverse"
     );
-    if (!import_fs4.default.existsSync(authversePathComponents)) {
-      import_fs4.default.mkdirSync(authversePathComponents, { recursive: true });
+    if (!import_fs6.default.existsSync(authversePathComponents)) {
+      import_fs6.default.mkdirSync(authversePathComponents, { recursive: true });
     }
-    import_fs4.default.copyFileSync(
+    import_fs6.default.copyFileSync(
       `${componentPath}/LoginComponent.tsx`,
-      import_path4.default.join(authversePathComponents, "LoginComponent.tsx")
+      import_path6.default.join(authversePathComponents, "LoginComponent.tsx")
     );
-    import_fs4.default.copyFileSync(
+    import_fs6.default.copyFileSync(
       `${componentPath}/SingUpComponent.tsx`,
-      import_path4.default.join(authversePathComponents, "SingUpComponent.tsx")
+      import_path6.default.join(authversePathComponents, "SingUpComponent.tsx")
     );
-    const pageRoutesPath = import_path4.default.join(`${srcPath}/routes`, "auth");
-    if (!import_fs4.default.existsSync(pageRoutesPath)) {
-      import_fs4.default.mkdirSync(pageRoutesPath, { recursive: true });
+    const pageRoutesPath = import_path6.default.join(`${srcPath}/routes`, "auth");
+    if (!import_fs6.default.existsSync(pageRoutesPath)) {
+      import_fs6.default.mkdirSync(pageRoutesPath, { recursive: true });
     }
-    const templateRoutesPage = import_path4.default.resolve(
+    const templateRoutesPage = import_path6.default.resolve(
       __dirname,
       "./template/TanstackStart/routes/auth"
     );
-    import_fs4.default.copyFileSync(
+    import_fs6.default.copyFileSync(
       `${templateRoutesPage}/login.tsx`,
-      import_path4.default.join(pageRoutesPath, "login.tsx")
+      import_path6.default.join(pageRoutesPath, "login.tsx")
     );
-    import_fs4.default.copyFileSync(
+    import_fs6.default.copyFileSync(
       `${templateRoutesPage}/signup.tsx`,
-      import_path4.default.join(pageRoutesPath, "signup.tsx")
+      import_path6.default.join(pageRoutesPath, "signup.tsx")
     );
-    const rootPath = import_path4.default.join(projectDir, "src/routes", "__root.tsx");
-    if (import_fs4.default.existsSync(rootPath)) {
-      let rootContent = import_fs4.default.readFileSync(rootPath, "utf-8");
+    const rootPath = import_path6.default.join(projectDir, "src/routes", "__root.tsx");
+    if (import_fs6.default.existsSync(rootPath)) {
+      let rootContent = import_fs6.default.readFileSync(rootPath, "utf-8");
       if (!rootContent.includes("Toaster")) {
         rootContent = `import { Toaster } from "@/components/ui/sonner";
 ${rootContent}`;
@@ -731,15 +1042,15 @@ ${rootContent}`;
           "    <Toaster />\n  </body>"
         );
       }
-      import_fs4.default.writeFileSync(rootPath, rootContent, "utf-8");
+      import_fs6.default.writeFileSync(rootPath, rootContent, "utf-8");
     }
-    console.log(import_chalk4.default.green("\nCompleted installation successfully"));
-    console.log(import_chalk4.default.cyan("\nInstall Package:"));
-    console.log(import_chalk4.default.white(`\u2022 ${database} schema
+    console.log(import_chalk6.default.green("\nCompleted installation successfully"));
+    console.log(import_chalk6.default.cyan("\nInstall Package:"));
+    console.log(import_chalk6.default.white(`\u2022 ${database} schema
 \u2022 better-auth`));
-    console.log(import_chalk4.default.cyan("\nFiles created:"));
+    console.log(import_chalk6.default.cyan("\nFiles created:"));
     console.log(
-      import_chalk4.default.white(
+      import_chalk6.default.white(
         `\u2022 src/lib/auth.ts
 \u2022 src/lib/auth-client.ts
 \u2022 src/app/api/auth/[...all]/route.ts
@@ -753,12 +1064,12 @@ ${rootContent}`;
       )
     );
   } catch (error) {
-    console.log(import_chalk4.default.red("Auth Ui Tanstack State Error: ", error));
+    console.log(import_chalk6.default.red("Auth Ui Tanstack State Error: ", error));
   }
 };
 
 // script/prismaRunTanstackStart.ts
-var import_meta5 = {};
+var import_meta6 = {};
 var prismaRunTanstackStart = async ({
   authUi,
   database,
@@ -766,12 +1077,12 @@ var prismaRunTanstackStart = async ({
 }) => {
   try {
     const projectDir = process.cwd();
-    const __filename = (0, import_url5.fileURLToPath)(import_meta5.url);
-    const __dirname = import_path5.default.dirname(__filename);
-    const packageJsonPath = import_path5.default.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(import_fs5.default.readFileSync(packageJsonPath, "utf-8"));
+    const __filename = (0, import_url6.fileURLToPath)(import_meta6.url);
+    const __dirname = import_path7.default.dirname(__filename);
+    const packageJsonPath = import_path7.default.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(import_fs7.default.readFileSync(packageJsonPath, "utf-8"));
     if (!packageJson2.devDependencies?.prisma || !packageJson2.dependencies?.["@prisma/client"]) {
-      console.log(import_chalk5.default.cyan("\n\u2699\uFE0F  Initializing Prisma...\n"));
+      console.log(import_chalk7.default.cyan("\n\u2699\uFE0F  Initializing Prisma...\n"));
       if (database !== "Mongodb") {
         packageManager("prisma", true);
         packageManager("@prisma/client");
@@ -786,98 +1097,98 @@ var prismaRunTanstackStart = async ({
         packageManager("@prisma/client@6.19.0");
       }
     }
-    const prismaDir = import_path5.default.join(projectDir, "prisma");
-    if (!import_fs5.default.existsSync(prismaDir)) {
-      console.log(import_chalk5.default.yellow("\n\u2699\uFE0F  Initializing Prisma...\n"));
+    const prismaDir = import_path7.default.join(projectDir, "prisma");
+    if (!import_fs7.default.existsSync(prismaDir)) {
+      console.log(import_chalk7.default.yellow("\n\u2699\uFE0F  Initializing Prisma...\n"));
       runCommand("prisma init");
-      const templatePath = import_path5.default.resolve(
+      const templatePath = import_path7.default.resolve(
         __dirname,
         `./template/prisma/${database}/schema.prisma`
       );
-      if (!import_fs5.default.existsSync(prismaDir)) {
-        import_fs5.default.mkdirSync(prismaDir, { recursive: true });
+      if (!import_fs7.default.existsSync(prismaDir)) {
+        import_fs7.default.mkdirSync(prismaDir, { recursive: true });
       }
-      const destinationPath = import_path5.default.join(prismaDir, "schema.prisma");
-      import_fs5.default.copyFileSync(templatePath, destinationPath);
+      const destinationPath = import_path7.default.join(prismaDir, "schema.prisma");
+      import_fs7.default.copyFileSync(templatePath, destinationPath);
       if (database === "Mongodb") {
-        const prismaConfigPath = import_path5.default.resolve(
+        const prismaConfigPath = import_path7.default.resolve(
           __dirname,
           `./template/config/prisma.config.ts`
         );
-        const prismaConfigDestinationPath = import_path5.default.join("", "prisma.config.ts");
-        import_fs5.default.copyFileSync(prismaConfigPath, prismaConfigDestinationPath);
+        const prismaConfigDestinationPath = import_path7.default.join("", "prisma.config.ts");
+        import_fs7.default.copyFileSync(prismaConfigPath, prismaConfigDestinationPath);
       }
     } else {
-      const schemaPath = import_path5.default.join(prismaDir, "schema.prisma");
-      const schemaContent = import_fs5.default.readFileSync(schemaPath, "utf-8");
+      const schemaPath = import_path7.default.join(prismaDir, "schema.prisma");
+      const schemaContent = import_fs7.default.readFileSync(schemaPath, "utf-8");
       if (!schemaContent.includes("User") || !schemaContent.includes("Session") || !schemaContent.includes("Account") || !schemaContent.includes("Verification")) {
-        const templatePath = import_path5.default.resolve(
+        const templatePath = import_path7.default.resolve(
           __dirname,
           `./template/prisma/${database}/schema.prisma_copy`
         );
-        import_fs5.default.appendFileSync(schemaPath, "\n");
-        import_fs5.default.appendFileSync(schemaPath, import_fs5.default.readFileSync(templatePath));
+        import_fs7.default.appendFileSync(schemaPath, "\n");
+        import_fs7.default.appendFileSync(schemaPath, import_fs7.default.readFileSync(templatePath));
       }
     }
     if (!packageJson2.dependencies?.["better-auth"]) {
-      console.log(import_chalk5.default.yellow("\n\u2699\uFE0F  Initializing better-auth...\n"));
+      console.log(import_chalk7.default.yellow("\n\u2699\uFE0F  Initializing better-auth...\n"));
       packageManager("better-auth");
     }
     const secret = await GenerateSecret();
-    const envPath = import_path5.default.join(projectDir, ".env");
-    const envContent = import_fs5.default.readFileSync(envPath, "utf-8");
+    const envPath = import_path7.default.join(projectDir, ".env");
+    const envContent = import_fs7.default.readFileSync(envPath, "utf-8");
     if (!envContent.includes("BETTER_AUTH_SECRET")) {
-      import_fs5.default.appendFileSync(envPath, `
+      import_fs7.default.appendFileSync(envPath, `
 
 BETTER_AUTH_SECRET=${secret}`);
     }
     if (!envContent.includes("BETTER_AUTH_URL")) {
-      import_fs5.default.appendFileSync(envPath, `
+      import_fs7.default.appendFileSync(envPath, `
 BETTER_AUTH_URL=http://localhost:3000
 `);
     }
-    const srcPath = import_path5.default.join(projectDir, "src");
-    const libPath = import_path5.default.join(srcPath, "lib");
-    if (!import_fs5.default.existsSync(libPath)) {
-      import_fs5.default.mkdirSync(libPath, { recursive: true });
+    const srcPath = import_path7.default.join(projectDir, "src");
+    const libPath = import_path7.default.join(srcPath, "lib");
+    if (!import_fs7.default.existsSync(libPath)) {
+      import_fs7.default.mkdirSync(libPath, { recursive: true });
     }
-    const authTemplatePath = import_path5.default.resolve(
+    const authTemplatePath = import_path7.default.resolve(
       __dirname,
       `./template/TanstackStart/lib/${database}/auth.ts`
     );
-    const authDestinationPath = import_path5.default.join(libPath, "auth.ts");
-    import_fs5.default.copyFileSync(authTemplatePath, authDestinationPath);
-    const authClientTemplatePath = import_path5.default.resolve(
+    const authDestinationPath = import_path7.default.join(libPath, "auth.ts");
+    import_fs7.default.copyFileSync(authTemplatePath, authDestinationPath);
+    const authClientTemplatePath = import_path7.default.resolve(
       __dirname,
       "./template/lib/auth-client.ts"
     );
-    const authClientDestinationPath = import_path5.default.join(libPath, "auth-client.ts");
-    import_fs5.default.copyFileSync(authClientTemplatePath, authClientDestinationPath);
-    const middlewarePath = import_path5.default.join(srcPath, "middleware");
-    if (!import_fs5.default.existsSync(middlewarePath)) {
-      import_fs5.default.mkdirSync(middlewarePath, { recursive: true });
+    const authClientDestinationPath = import_path7.default.join(libPath, "auth-client.ts");
+    import_fs7.default.copyFileSync(authClientTemplatePath, authClientDestinationPath);
+    const middlewarePath = import_path7.default.join(srcPath, "middleware");
+    if (!import_fs7.default.existsSync(middlewarePath)) {
+      import_fs7.default.mkdirSync(middlewarePath, { recursive: true });
     }
-    const authMiddlewareTemplatePath = import_path5.default.resolve(
+    const authMiddlewareTemplatePath = import_path7.default.resolve(
       __dirname,
       `./template/TanstackStart/middleware/auth.ts`
     );
-    const authMiddlewareDestinationPath = import_path5.default.join(middlewarePath, "auth.ts");
-    import_fs5.default.copyFileSync(authMiddlewareTemplatePath, authMiddlewareDestinationPath);
-    const fileRouteTemplatePath = import_path5.default.resolve(
+    const authMiddlewareDestinationPath = import_path7.default.join(middlewarePath, "auth.ts");
+    import_fs7.default.copyFileSync(authMiddlewareTemplatePath, authMiddlewareDestinationPath);
+    const fileRouteTemplatePath = import_path7.default.resolve(
       __dirname,
       `./template/TanstackStart/routes/$.ts`
     );
-    const fileRouteDestinationPath = import_path5.default.join(
+    const fileRouteDestinationPath = import_path7.default.join(
       srcPath,
       "routes",
       "api",
       "auth"
     );
-    if (!import_fs5.default.existsSync(fileRouteDestinationPath)) {
-      import_fs5.default.mkdirSync(fileRouteDestinationPath, { recursive: true });
+    if (!import_fs7.default.existsSync(fileRouteDestinationPath)) {
+      import_fs7.default.mkdirSync(fileRouteDestinationPath, { recursive: true });
     }
-    const apiDestinationPath = import_path5.default.join(fileRouteDestinationPath, "$.ts");
-    import_fs5.default.copyFileSync(fileRouteTemplatePath, apiDestinationPath);
+    const apiDestinationPath = import_path7.default.join(fileRouteDestinationPath, "$.ts");
+    import_fs7.default.copyFileSync(fileRouteTemplatePath, apiDestinationPath);
     if (authUi) {
       await authUiTanstackState({
         packageJson: packageJson2,
@@ -885,13 +1196,13 @@ BETTER_AUTH_URL=http://localhost:3000
         database: "prisma"
       });
     } else {
-      console.log(import_chalk5.default.green("\nCompleted installation successfully"));
-      console.log(import_chalk5.default.cyan("\nInstall Package:"));
-      console.log(import_chalk5.default.white(`\u2022 prisma ${database} schema
+      console.log(import_chalk7.default.green("\nCompleted installation successfully"));
+      console.log(import_chalk7.default.cyan("\nInstall Package:"));
+      console.log(import_chalk7.default.white(`\u2022 prisma ${database} schema
 \u2022 better-auth`));
-      console.log(import_chalk5.default.cyan("\nFiles created:"));
+      console.log(import_chalk7.default.cyan("\nFiles created:"));
       console.log(
-        import_chalk5.default.white(
+        import_chalk7.default.white(
           `\u2022 src/lib/auth.ts
 \u2022 src/lib/auth-client.ts
 \u2022 src/app/api/auth/[...all]/route.ts
@@ -901,111 +1212,116 @@ BETTER_AUTH_URL=http://localhost:3000
       );
     }
   } catch (err) {
-    console.log(import_chalk5.default.red("Prisma Run Tanstack State Error: ", err));
+    console.log(import_chalk7.default.red("Prisma Run Tanstack State Error: ", err));
   }
 };
 
 // script/drizzleRunTanstackStart.ts
-var import_chalk6 = __toESM(require("chalk"), 1);
-var import_path6 = __toESM(require("path"), 1);
-var import_fs6 = __toESM(require("fs"), 1);
-var import_url6 = require("url");
-var import_meta6 = {};
-var drizzleRunTanstackStart = async ({
+var import_chalk10 = __toESM(require("chalk"), 1);
+var import_path10 = __toESM(require("path"), 1);
+var import_fs10 = __toESM(require("fs"), 1);
+
+// drizzle/drizzleTanstackSetup.ts
+var import_chalk8 = __toESM(require("chalk"), 1);
+var import_path8 = __toESM(require("path"), 1);
+var import_fs8 = __toESM(require("fs"), 1);
+var import_url7 = require("url");
+var import_meta7 = {};
+var drizzleTanstackSetup = async ({
   authUi,
-  cmd
+  cmd,
+  projectDir
 }) => {
   try {
-    const projectDir = process.cwd();
-    const packageJsonPath = import_path6.default.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(import_fs6.default.readFileSync(packageJsonPath, "utf-8"));
+    const packageJsonPath = import_path8.default.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(import_fs8.default.readFileSync(packageJsonPath, "utf-8"));
     if (!packageJson2.dependencies["better-auth"]) {
-      console.log(import_chalk6.default.cyan("\n\u2699\uFE0F  Initializing better auth...\n"));
+      console.log(import_chalk8.default.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(import_chalk6.default.cyan("\n\u2699\uFE0F  Initializing drizzle...\n"));
+      console.log(import_chalk8.default.cyan("\n\u2699\uFE0F  Initializing drizzle...\n"));
       packageManager("drizzle-orm @neondatabase/serverless dotenv");
       packageManager("drizzle-kit", true);
     }
-    const __filename = (0, import_url6.fileURLToPath)(import_meta6.url);
-    const __dirname = import_path6.default.dirname(__filename);
-    const envPath = import_path6.default.join(projectDir, ".env");
-    if (!import_fs6.default.existsSync(envPath)) {
-      import_fs6.default.writeFileSync(envPath, "DATABASE_URL=\n");
+    const __filename = (0, import_url7.fileURLToPath)(import_meta7.url);
+    const __dirname = import_path8.default.dirname(__filename);
+    const envPath = import_path8.default.join(projectDir, ".env");
+    if (!import_fs8.default.existsSync(envPath)) {
+      import_fs8.default.writeFileSync(envPath, "DATABASE_URL=\n");
     }
     const secret = await GenerateSecret();
-    const envContent = import_fs6.default.readFileSync(envPath, "utf-8");
+    const envContent = import_fs8.default.readFileSync(envPath, "utf-8");
     if (!envContent.includes("BETTER_AUTH_SECRET")) {
-      import_fs6.default.appendFileSync(envPath, `
+      import_fs8.default.appendFileSync(envPath, `
 
 BETTER_AUTH_SECRET=${secret}`);
     }
     if (!envContent.includes("BETTER_AUTH_URL")) {
-      import_fs6.default.appendFileSync(envPath, `
+      import_fs8.default.appendFileSync(envPath, `
 BETTER_AUTH_URL=http://localhost:3000
 `);
     }
-    const srcPath = import_path6.default.join(projectDir, "src");
-    const libPath = import_path6.default.join(srcPath, "lib");
-    if (!import_fs6.default.existsSync(libPath)) {
-      import_fs6.default.mkdirSync(libPath, { recursive: true });
+    const srcPath = import_path8.default.join(projectDir, "src");
+    const libPath = import_path8.default.join(srcPath, "lib");
+    if (!import_fs8.default.existsSync(libPath)) {
+      import_fs8.default.mkdirSync(libPath, { recursive: true });
     }
-    const authTemplatePath = import_path6.default.resolve(
+    const authTemplatePath = import_path8.default.resolve(
       __dirname,
       "./template/TanstackStart/lib/auth-drizzle.ts"
     );
-    const authDestinationPath = import_path6.default.join(libPath, "auth.ts");
-    import_fs6.default.copyFileSync(authTemplatePath, authDestinationPath);
-    const authClientTemplatePath = import_path6.default.resolve(
+    const authDestinationPath = import_path8.default.join(libPath, "auth.ts");
+    import_fs8.default.copyFileSync(authTemplatePath, authDestinationPath);
+    const authClientTemplatePath = import_path8.default.resolve(
       __dirname,
       "./template/lib/auth-client.ts"
     );
-    const authClientDestinationPath = import_path6.default.join(libPath, "auth-client.ts");
-    import_fs6.default.copyFileSync(authClientTemplatePath, authClientDestinationPath);
-    const dbTemplatePath = import_path6.default.resolve(__dirname, "./template/db");
-    const dbDir = import_path6.default.join(projectDir, "db");
-    if (!import_fs6.default.existsSync(dbDir)) {
-      import_fs6.default.mkdirSync(dbDir, { recursive: true });
-    }
-    const dbDestinationPath = import_path6.default.join(dbDir, "drizzle.ts");
-    import_fs6.default.copyFileSync(`${dbTemplatePath}/drizzle.ts`, dbDestinationPath);
-    const schemaDestinationPath = import_path6.default.join(dbDir, "schema.ts");
-    import_fs6.default.copyFileSync(`${dbTemplatePath}/schema.ts`, schemaDestinationPath);
-    const drizzleConfigTemplatePath = import_path6.default.resolve(
+    const authClientDestinationPath = import_path8.default.join(libPath, "auth-client.ts");
+    import_fs8.default.copyFileSync(authClientTemplatePath, authClientDestinationPath);
+    const dbTemplatePath = import_path8.default.resolve(__dirname, "./template/db");
+    const dbDir = import_path8.default.join(projectDir, "db");
+    if (!import_fs8.default.existsSync(dbDir)) {
+      import_fs8.default.mkdirSync(dbDir, { recursive: true });
+    }
+    const dbDestinationPath = import_path8.default.join(dbDir, "drizzle.ts");
+    import_fs8.default.copyFileSync(`${dbTemplatePath}/drizzle.ts`, dbDestinationPath);
+    const schemaDestinationPath = import_path8.default.join(dbDir, "schema.ts");
+    import_fs8.default.copyFileSync(`${dbTemplatePath}/schema.ts`, schemaDestinationPath);
+    const drizzleConfigTemplatePath = import_path8.default.resolve(
       __dirname,
       "./template/config/drizzle.config.ts"
     );
-    const drizzleConfigDestinationPath = import_path6.default.join(
+    const drizzleConfigDestinationPath = import_path8.default.join(
       projectDir,
       "drizzle.config.ts"
     );
-    import_fs6.default.copyFileSync(drizzleConfigTemplatePath, drizzleConfigDestinationPath);
-    const middlewarePath = import_path6.default.join(srcPath, "middleware");
-    if (!import_fs6.default.existsSync(middlewarePath)) {
-      import_fs6.default.mkdirSync(middlewarePath, { recursive: true });
+    import_fs8.default.copyFileSync(drizzleConfigTemplatePath, drizzleConfigDestinationPath);
+    const middlewarePath = import_path8.default.join(srcPath, "middleware");
+    if (!import_fs8.default.existsSync(middlewarePath)) {
+      import_fs8.default.mkdirSync(middlewarePath, { recursive: true });
     }
-    const authMiddlewareTemplatePath = import_path6.default.resolve(
+    const authMiddlewareTemplatePath = import_path8.default.resolve(
       __dirname,
       `./template/TanstackStart/middleware/auth.ts`
     );
-    const authMiddlewareDestinationPath = import_path6.default.join(middlewarePath, "auth.ts");
-    import_fs6.default.copyFileSync(authMiddlewareTemplatePath, authMiddlewareDestinationPath);
-    const fileRouteTemplatePath = import_path6.default.resolve(
+    const authMiddlewareDestinationPath = import_path8.default.join(middlewarePath, "auth.ts");
+    import_fs8.default.copyFileSync(authMiddlewareTemplatePath, authMiddlewareDestinationPath);
+    const fileRouteTemplatePath = import_path8.default.resolve(
       __dirname,
       `./template/TanstackStart/routes/$.ts`
     );
-    const fileRouteDestinationPath = import_path6.default.join(
+    const fileRouteDestinationPath = import_path8.default.join(
       srcPath,
       "routes",
       "api",
       "auth"
     );
-    if (!import_fs6.default.existsSync(fileRouteDestinationPath)) {
-      import_fs6.default.mkdirSync(fileRouteDestinationPath, { recursive: true });
+    if (!import_fs8.default.existsSync(fileRouteDestinationPath)) {
+      import_fs8.default.mkdirSync(fileRouteDestinationPath, { recursive: true });
     }
-    const apiDestinationPath = import_path6.default.join(fileRouteDestinationPath, "$.ts");
-    import_fs6.default.copyFileSync(fileRouteTemplatePath, apiDestinationPath);
+    const apiDestinationPath = import_path8.default.join(fileRouteDestinationPath, "$.ts");
+    import_fs8.default.copyFileSync(fileRouteTemplatePath, apiDestinationPath);
     if (authUi) {
       await authUiTanstackState({
         packageJson: packageJson2,
@@ -1013,13 +1329,13 @@ BETTER_AUTH_URL=http://localhost:3000
         database: "drizzle"
       });
     } else {
-      console.log(import_chalk6.default.green("\nCompleted installation successfully"));
-      console.log(import_chalk6.default.cyan("\nInstall Package:"));
-      console.log(import_chalk6.default.white(`\u2022 drizzle schema
+      console.log(import_chalk8.default.green("\nCompleted installation successfully"));
+      console.log(import_chalk8.default.cyan("\nInstall Package:"));
+      console.log(import_chalk8.default.white(`\u2022 drizzle schema
 \u2022 better-auth`));
-      console.log(import_chalk6.default.cyan("\nFiles created:"));
+      console.log(import_chalk8.default.cyan("\nFiles created:"));
       console.log(
-        import_chalk6.default.white(
+        import_chalk8.default.white(
           `\u2022 src/lib/auth.ts
 \u2022 src/lib/auth-client.ts
 \u2022 src/app/api/auth/[...all]/route.ts
@@ -1028,74 +1344,295 @@ BETTER_AUTH_URL=http://localhost:3000
         )
       );
     }
-  } catch (err) {
-    console.error(import_chalk6.default.red("Drizzle setup failed:"), err);
-  }
-};
-
-// utils/framework.ts
-var import_path7 = __toESM(require("path"), 1);
-var import_fs7 = __toESM(require("fs"), 1);
-var getFramework = async () => {
-  const projectDir = process.cwd();
-  if (!import_fs7.default.existsSync(import_path7.default.join(projectDir, "package.json"))) {
-    return {
-      framework: null,
-      error: "No framework detected"
-    };
-  }
-  const packageJson2 = JSON.parse(
-    import_fs7.default.readFileSync(import_path7.default.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(import_chalk8.default.red("Failed to setup drizzle ", error));
   }
-  return {
-    framework: null,
-    error: "No framework supported authverse"
-  };
 };
 
-// cli/init.ts
-var import_chalk7 = __toESM(require("chalk"), 1);
-var initAnswer = async () => {
-  const { framework, error } = await getFramework();
-  if (error) {
-    console.log(import_chalk7.default.red(error));
-    return;
-  }
-  console.log(`\u2714 Detected framework: ${framework}`);
-  const answers = await import_inquirer3.default.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
+var import_chalk9 = __toESM(require("chalk"), 1);
+var import_path9 = __toESM(require("path"), 1);
+var import_fs9 = __toESM(require("fs"), 1);
+var import_url8 = require("url");
+var import_meta8 = {};
+var drizzleTanstackChecker = async ({
+  authUi,
+  cmd,
+  projectDir
+}) => {
+  try {
+    const drizzleConfigPath = import_path9.default.join(projectDir, "drizzle.config.ts");
+    if (!import_fs9.default.existsSync(drizzleConfigPath)) {
+      return await drizzleTanstackSetup({ authUi, cmd, projectDir });
+    }
+    const drizzleConfigContent = import_fs9.default.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 = (0, import_url8.fileURLToPath)(import_meta8.url);
+    const __dirname = import_path9.default.dirname(__filename);
+    const dbTemplatePath = import_path9.default.resolve(__dirname, "./template/db/schema.ts");
+    const schemaFilePath = import_path9.default.join(projectDir, schemaPath);
+    if (!import_fs9.default.existsSync(schemaFilePath)) {
+      const dbFolder = import_path9.default.dirname(schemaFilePath);
+      if (!import_fs9.default.existsSync(dbFolder)) {
+        import_fs9.default.mkdirSync(dbFolder, { recursive: true });
+      }
+      import_fs9.default.copyFileSync(dbTemplatePath, schemaFilePath);
+    } else {
+      let schemaFileContent = import_fs9.default.readFileSync(schemaFilePath, "utf-8");
+      const dbTemplateContent = import_fs9.default.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}};`
+          );
+        }
+        import_fs9.default.writeFileSync(schemaFilePath, updatedSchemaContent);
+      }
+    }
+    const packageJsonPath = import_path9.default.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(import_fs9.default.readFileSync(packageJsonPath, "utf-8"));
+    if (!packageJson2.dependencies["better-auth"]) {
+      console.log(import_chalk9.default.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(import_chalk9.default.cyan("\n\u2699\uFE0F  Initializing drizzle...\n"));
+      packageManager(missingDrizzleDeps.join(" "));
+    }
+    const envPath = import_path9.default.join(projectDir, ".env");
+    if (!import_fs9.default.existsSync(envPath)) {
+      import_fs9.default.writeFileSync(envPath, "DATABASE_URL=\n");
+    }
+    const secret = await GenerateSecret();
+    const envContent = import_fs9.default.readFileSync(envPath, "utf-8");
+    if (!envContent.includes("BETTER_AUTH_SECRET")) {
+      import_fs9.default.appendFileSync(envPath, `
+
+BETTER_AUTH_SECRET=${secret}`);
+    }
+    if (!envContent.includes("BETTER_AUTH_URL")) {
+      import_fs9.default.appendFileSync(envPath, `
+BETTER_AUTH_URL=http://localhost:3000
+`);
+    }
+    const srcPath = import_path9.default.join(projectDir, "src");
+    const libPath = import_path9.default.join(srcPath, "lib");
+    if (!import_fs9.default.existsSync(libPath)) {
+      import_fs9.default.mkdirSync(libPath, { recursive: true });
+    }
+    const authTemplatePath = import_path9.default.resolve(
+      __dirname,
+      "./template/TanstackStart/lib/auth-drizzle.ts"
+    );
+    const authDestinationPath = import_path9.default.join(libPath, "auth.ts");
+    import_fs9.default.copyFileSync(authTemplatePath, authDestinationPath);
+    const authClientTemplatePath = import_path9.default.resolve(
+      __dirname,
+      "./template/lib/auth-client.ts"
+    );
+    const authClientDestinationPath = import_path9.default.join(libPath, "auth-client.ts");
+    import_fs9.default.copyFileSync(authClientTemplatePath, authClientDestinationPath);
+    const middlewarePath = import_path9.default.join(srcPath, "middleware");
+    if (!import_fs9.default.existsSync(middlewarePath)) {
+      import_fs9.default.mkdirSync(middlewarePath, { recursive: true });
+    }
+    const authMiddlewareTemplatePath = import_path9.default.resolve(
+      __dirname,
+      `./template/TanstackStart/middleware/auth.ts`
+    );
+    const authMiddlewareDestinationPath = import_path9.default.join(middlewarePath, "auth.ts");
+    import_fs9.default.copyFileSync(authMiddlewareTemplatePath, authMiddlewareDestinationPath);
+    const fileRouteTemplatePath = import_path9.default.resolve(
+      __dirname,
+      `./template/TanstackStart/routes/$.ts`
+    );
+    const fileRouteDestinationPath = import_path9.default.join(
+      srcPath,
+      "routes",
+      "api",
+      "auth"
+    );
+    if (!import_fs9.default.existsSync(fileRouteDestinationPath)) {
+      import_fs9.default.mkdirSync(fileRouteDestinationPath, { recursive: true });
+    }
+    const apiDestinationPath = import_path9.default.join(fileRouteDestinationPath, "$.ts");
+    import_fs9.default.copyFileSync(fileRouteTemplatePath, apiDestinationPath);
+    if (authUi) {
+      await authUiTanstackState({
+        packageJson: packageJson2,
+        cmd,
+        database: "drizzle"
+      });
+    } else {
+      console.log(import_chalk9.default.green("\nCompleted installation successfully"));
+      console.log(import_chalk9.default.cyan("\nInstall Package:"));
+      console.log(import_chalk9.default.white(`\u2022 drizzle schema
+\u2022 better-auth`));
+      console.log(import_chalk9.default.cyan("\nFiles created:"));
+      console.log(
+        import_chalk9.default.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(import_chalk9.default.red("Failed to setup drizzle ", error));
+  }
+};
+
+// script/drizzleRunTanstackStart.ts
+var drizzleRunTanstackStart = async ({
+  authUi,
+  cmd
+}) => {
+  try {
+    const projectDir = process.cwd();
+    const drizzleConfigPath = import_path10.default.join(projectDir, "drizzle.config.ts");
+    if (import_fs10.default.existsSync(drizzleConfigPath)) {
+      await drizzleTanstackChecker({ authUi, cmd, projectDir });
+    } else {
+      await drizzleTanstackSetup({ authUi, cmd, projectDir });
+    }
+  } catch (err) {
+    console.error(import_chalk10.default.red("Drizzle setup failed:"), err);
+  }
+};
+
+// utils/framework.ts
+var import_path11 = __toESM(require("path"), 1);
+var import_fs11 = __toESM(require("fs"), 1);
+var getFramework = async () => {
+  const projectDir = process.cwd();
+  if (!import_fs11.default.existsSync(import_path11.default.join(projectDir, "package.json"))) {
+    return {
+      framework: null,
+      error: "No framework detected"
+    };
+  }
+  const packageJson2 = JSON.parse(
+    import_fs11.default.readFileSync(import_path11.default.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
+var import_chalk11 = __toESM(require("chalk"), 1);
+var initAnswer = async () => {
+  const { framework, error } = await getFramework();
+  if (error) {
+    console.log(import_chalk11.default.red(error));
+    return;
+  }
+  console.log(`\u2714 Detected framework: ${framework}`);
+  const answers = await import_inquirer4.default.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") {
     await prismaRun({
@@ -1126,37 +1663,37 @@ var initAnswer = async () => {
 };
 
 // index.ts
-var import_fs31 = require("fs");
+var import_fs35 = require("fs");
 
 // cli/oauth.ts
-var import_chalk20 = __toESM(require("chalk"), 1);
+var import_chalk24 = __toESM(require("chalk"), 1);
 
 // oauth/googleNext.ts
-var import_chalk8 = __toESM(require("chalk"), 1);
-var import_fs8 = __toESM(require("fs"), 1);
-var import_path8 = __toESM(require("path"), 1);
-var import_url7 = require("url");
-var import_meta7 = {};
+var import_chalk12 = __toESM(require("chalk"), 1);
+var import_fs12 = __toESM(require("fs"), 1);
+var import_path12 = __toESM(require("path"), 1);
+var import_url9 = require("url");
+var import_meta9 = {};
 var googleNext = async () => {
   try {
-    const __filename = (0, import_url7.fileURLToPath)(import_meta7.url);
-    const __dirname = import_path8.default.dirname(__filename);
+    const __filename = (0, import_url9.fileURLToPath)(import_meta9.url);
+    const __dirname = import_path12.default.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = import_path8.default.join(projectDir, "src");
-    const folder = import_fs8.default.existsSync(srcPath) ? "src" : "";
-    const authFilePath = import_path8.default.join(projectDir, folder, "lib", "auth.ts");
-    if (!import_fs8.default.existsSync(authFilePath)) {
-      console.log(import_chalk8.default.red("No Configured Better Auth file found"));
-      console.log(import_chalk8.default.cyan("Run authverse init to initialize better auth"));
+    const srcPath = import_path12.default.join(projectDir, "src");
+    const folder = import_fs12.default.existsSync(srcPath) ? "src" : "";
+    const authFilePath = import_path12.default.join(projectDir, folder, "lib", "auth.ts");
+    if (!import_fs12.default.existsSync(authFilePath)) {
+      console.log(import_chalk12.default.red("No Configured Better Auth file found"));
+      console.log(import_chalk12.default.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = import_fs8.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs12.default.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(import_chalk8.default.red("betterAuth({}) block not found"));
+      console.log(import_chalk12.default.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("google:")) {
-      console.log(import_chalk8.default.yellow("Google provider already exists"));
+      console.log(import_chalk12.default.yellow("Google provider already exists"));
       return;
     }
     const googleProviderEntry = `
@@ -1179,7 +1716,7 @@ var googleNext = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(import_chalk8.default.red("Failed to parse socialProviders block"));
+        console.log(import_chalk12.default.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + googleProviderEntry + "\n  " + content.slice(insertPos);
@@ -1187,7 +1724,7 @@ var googleNext = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          import_chalk8.default.red(
+          import_chalk12.default.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1203,12 +1740,12 @@ ${googleProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    import_fs8.default.writeFileSync(authFilePath, content, "utf8");
-    const envPath = import_path8.default.join(projectDir, ".env");
-    if (import_fs8.default.existsSync(envPath)) {
-      const envContent = import_fs8.default.readFileSync(envPath, "utf8");
+    import_fs12.default.writeFileSync(authFilePath, content, "utf8");
+    const envPath = import_path12.default.join(projectDir, ".env");
+    if (import_fs12.default.existsSync(envPath)) {
+      const envContent = import_fs12.default.readFileSync(envPath, "utf8");
       if (!envContent.includes("GOOGLE_CLIENT_ID")) {
-        import_fs8.default.appendFileSync(
+        import_fs12.default.appendFileSync(
           envPath,
           `
 
@@ -1219,61 +1756,61 @@ GOOGLE_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = import_path8.default.resolve(
+    const componentTemplate = import_path12.default.resolve(
       __dirname,
       "./template/components/GoogleOAuthButton.tsx"
     );
-    const componentsDir = import_path8.default.join(
+    const componentsDir = import_path12.default.join(
       projectDir,
       folder,
       "components",
       "authverse"
     );
-    if (!import_fs8.default.existsSync(componentsDir)) {
-      import_fs8.default.mkdirSync(componentsDir, { recursive: true });
+    if (!import_fs12.default.existsSync(componentsDir)) {
+      import_fs12.default.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = import_path8.default.join(componentsDir, "GoogleOAuthButton.tsx");
-    if (import_fs8.default.existsSync(componentTemplate)) {
-      import_fs8.default.copyFileSync(componentTemplate, componentDest);
+    const componentDest = import_path12.default.join(componentsDir, "GoogleOAuthButton.tsx");
+    if (import_fs12.default.existsSync(componentTemplate)) {
+      import_fs12.default.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(import_chalk8.default.green("Google provider added & merged successfully\n"));
+    console.log(import_chalk12.default.green("Google provider added & merged successfully\n"));
     console.log(
-      import_chalk8.default.white(
+      import_chalk12.default.white(
         `${CreateFolder({ srcFolder: folder, destFolder: "components/authverse/GoogleOAuthButton.tsx" })}
 `
       )
     );
   } catch (error) {
-    console.log(import_chalk8.default.red("googleRun error:"), error);
+    console.log(import_chalk12.default.red("googleRun error:"), error);
   }
 };
 
 // oauth/githubNext.ts
-var import_chalk9 = __toESM(require("chalk"), 1);
-var import_fs9 = __toESM(require("fs"), 1);
-var import_path9 = __toESM(require("path"), 1);
-var import_url8 = require("url");
-var import_meta8 = {};
+var import_chalk13 = __toESM(require("chalk"), 1);
+var import_fs13 = __toESM(require("fs"), 1);
+var import_path13 = __toESM(require("path"), 1);
+var import_url10 = require("url");
+var import_meta10 = {};
 var githubNext = async () => {
   try {
-    const __filename = (0, import_url8.fileURLToPath)(import_meta8.url);
-    const __dirname = import_path9.default.dirname(__filename);
+    const __filename = (0, import_url10.fileURLToPath)(import_meta10.url);
+    const __dirname = import_path13.default.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = import_path9.default.join(projectDir, "src");
-    const folder = import_fs9.default.existsSync(srcPath) ? "src" : "";
-    const authFilePath = import_path9.default.join(projectDir, folder, "lib", "auth.ts");
-    if (!import_fs9.default.existsSync(authFilePath)) {
-      console.log(import_chalk9.default.red("No Configured Better Auth file found"));
-      console.log(import_chalk9.default.cyan("Run authverse init to initialize better auth"));
+    const srcPath = import_path13.default.join(projectDir, "src");
+    const folder = import_fs13.default.existsSync(srcPath) ? "src" : "";
+    const authFilePath = import_path13.default.join(projectDir, folder, "lib", "auth.ts");
+    if (!import_fs13.default.existsSync(authFilePath)) {
+      console.log(import_chalk13.default.red("No Configured Better Auth file found"));
+      console.log(import_chalk13.default.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = import_fs9.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs13.default.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(import_chalk9.default.red("betterAuth({}) block not found"));
+      console.log(import_chalk13.default.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("github:")) {
-      console.log(import_chalk9.default.yellow("GitHub provider already exists"));
+      console.log(import_chalk13.default.yellow("GitHub provider already exists"));
       return;
     }
     const githubProviderEntry = `
@@ -1296,7 +1833,7 @@ var githubNext = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(import_chalk9.default.red("Failed to parse socialProviders block"));
+        console.log(import_chalk13.default.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + githubProviderEntry + "\n  " + content.slice(insertPos);
@@ -1304,7 +1841,7 @@ var githubNext = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          import_chalk9.default.red(
+          import_chalk13.default.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1320,12 +1857,12 @@ ${githubProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    import_fs9.default.writeFileSync(authFilePath, content, "utf8");
-    const envPath = import_path9.default.join(projectDir, ".env");
-    if (import_fs9.default.existsSync(envPath)) {
-      const envContent = import_fs9.default.readFileSync(envPath, "utf8");
+    import_fs13.default.writeFileSync(authFilePath, content, "utf8");
+    const envPath = import_path13.default.join(projectDir, ".env");
+    if (import_fs13.default.existsSync(envPath)) {
+      const envContent = import_fs13.default.readFileSync(envPath, "utf8");
       if (!envContent.includes("GITHUB_CLIENT_ID")) {
-        import_fs9.default.appendFileSync(
+        import_fs13.default.appendFileSync(
           envPath,
           `
 
@@ -1336,60 +1873,60 @@ GITHUB_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = import_path9.default.resolve(
+    const componentTemplate = import_path13.default.resolve(
       __dirname,
       "./template/components/GithubOAuthButton.tsx"
     );
-    const componentsDir = import_path9.default.join(
+    const componentsDir = import_path13.default.join(
       projectDir,
       folder,
       "components",
       "authverse"
     );
-    if (!import_fs9.default.existsSync(componentsDir)) {
-      import_fs9.default.mkdirSync(componentsDir, { recursive: true });
+    if (!import_fs13.default.existsSync(componentsDir)) {
+      import_fs13.default.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = import_path9.default.join(componentsDir, "GithubOAuthButton.tsx");
-    if (import_fs9.default.existsSync(componentTemplate)) {
-      import_fs9.default.copyFileSync(componentTemplate, componentDest);
+    const componentDest = import_path13.default.join(componentsDir, "GithubOAuthButton.tsx");
+    if (import_fs13.default.existsSync(componentTemplate)) {
+      import_fs13.default.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(import_chalk9.default.green("GitHub provider added & merged successfully\n"));
+    console.log(import_chalk13.default.green("GitHub provider added & merged successfully\n"));
     console.log(
-      import_chalk9.default.white(
+      import_chalk13.default.white(
         `${CreateFolder({ srcFolder: folder, destFolder: "components/authverse/GithubOAuthButton.tsx" })}
 `
       )
     );
   } catch (error) {
-    console.log(import_chalk9.default.red("githubRun error:"), error);
+    console.log(import_chalk13.default.red("githubRun error:"), error);
   }
 };
 
 // oauth/googleTanstackStart.ts
-var import_chalk10 = __toESM(require("chalk"), 1);
-var import_fs10 = __toESM(require("fs"), 1);
-var import_path10 = __toESM(require("path"), 1);
-var import_url9 = require("url");
-var import_meta9 = {};
+var import_chalk14 = __toESM(require("chalk"), 1);
+var import_fs14 = __toESM(require("fs"), 1);
+var import_path14 = __toESM(require("path"), 1);
+var import_url11 = require("url");
+var import_meta11 = {};
 var googleTanstackStart = async () => {
   try {
-    const __filename = (0, import_url9.fileURLToPath)(import_meta9.url);
-    const __dirname = import_path10.default.dirname(__filename);
+    const __filename = (0, import_url11.fileURLToPath)(import_meta11.url);
+    const __dirname = import_path14.default.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = import_path10.default.join(projectDir, "src");
-    const authFilePath = import_path10.default.join(srcPath, "lib", "auth.ts");
-    if (!import_fs10.default.existsSync(authFilePath)) {
-      console.log(import_chalk10.default.red("No Configured Better Auth file found"));
-      console.log(import_chalk10.default.cyan("Run authverse init to initialize better auth"));
+    const srcPath = import_path14.default.join(projectDir, "src");
+    const authFilePath = import_path14.default.join(srcPath, "lib", "auth.ts");
+    if (!import_fs14.default.existsSync(authFilePath)) {
+      console.log(import_chalk14.default.red("No Configured Better Auth file found"));
+      console.log(import_chalk14.default.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = import_fs10.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs14.default.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(import_chalk10.default.red("betterAuth({}) block not found"));
+      console.log(import_chalk14.default.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("google:")) {
-      console.log(import_chalk10.default.yellow("Google provider already exists"));
+      console.log(import_chalk14.default.yellow("Google provider already exists"));
       return;
     }
     const googleProviderEntry = `
@@ -1412,7 +1949,7 @@ var googleTanstackStart = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(import_chalk10.default.red("Failed to parse socialProviders block"));
+        console.log(import_chalk14.default.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + googleProviderEntry + "\n  " + content.slice(insertPos);
@@ -1420,7 +1957,7 @@ var googleTanstackStart = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          import_chalk10.default.red(
+          import_chalk14.default.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1436,12 +1973,12 @@ ${googleProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    import_fs10.default.writeFileSync(authFilePath, content, "utf8");
-    const envPath = import_path10.default.join(projectDir, ".env");
-    if (import_fs10.default.existsSync(envPath)) {
-      const envContent = import_fs10.default.readFileSync(envPath, "utf8");
+    import_fs14.default.writeFileSync(authFilePath, content, "utf8");
+    const envPath = import_path14.default.join(projectDir, ".env");
+    if (import_fs14.default.existsSync(envPath)) {
+      const envContent = import_fs14.default.readFileSync(envPath, "utf8");
       if (!envContent.includes("GOOGLE_CLIENT_ID")) {
-        import_fs10.default.appendFileSync(
+        import_fs14.default.appendFileSync(
           envPath,
           `
 
@@ -1452,52 +1989,52 @@ GOOGLE_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = import_path10.default.resolve(
+    const componentTemplate = import_path14.default.resolve(
       __dirname,
       "./template/TanstackStart/components/GoogleOAuthButton.tsx"
     );
-    const componentsDir = import_path10.default.join(srcPath, "components", "authverse");
-    if (!import_fs10.default.existsSync(componentsDir)) {
-      import_fs10.default.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = import_path14.default.join(srcPath, "components", "authverse");
+    if (!import_fs14.default.existsSync(componentsDir)) {
+      import_fs14.default.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = import_path10.default.join(componentsDir, "GoogleOAuthButton.tsx");
-    if (import_fs10.default.existsSync(componentTemplate)) {
-      import_fs10.default.copyFileSync(componentTemplate, componentDest);
+    const componentDest = import_path14.default.join(componentsDir, "GoogleOAuthButton.tsx");
+    if (import_fs14.default.existsSync(componentTemplate)) {
+      import_fs14.default.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(import_chalk10.default.green("Google provider added & merged successfully\n"));
+    console.log(import_chalk14.default.green("Google provider added & merged successfully\n"));
     console.log(
-      import_chalk10.default.white("\u2022 src/components/authverse/GoogleOAuthButton.tsx")
+      import_chalk14.default.white("\u2022 src/components/authverse/GoogleOAuthButton.tsx")
     );
   } catch (error) {
-    console.log(import_chalk10.default.red("googleRunTanstackState error:"), error);
+    console.log(import_chalk14.default.red("googleRunTanstackState error:"), error);
   }
 };
 
 // oauth/githubTanstackStart.ts
-var import_chalk11 = __toESM(require("chalk"), 1);
-var import_fs11 = __toESM(require("fs"), 1);
-var import_path11 = __toESM(require("path"), 1);
-var import_url10 = require("url");
-var import_meta10 = {};
+var import_chalk15 = __toESM(require("chalk"), 1);
+var import_fs15 = __toESM(require("fs"), 1);
+var import_path15 = __toESM(require("path"), 1);
+var import_url12 = require("url");
+var import_meta12 = {};
 var githubTanstackStart = async () => {
   try {
-    const __filename = (0, import_url10.fileURLToPath)(import_meta10.url);
-    const __dirname = import_path11.default.dirname(__filename);
+    const __filename = (0, import_url12.fileURLToPath)(import_meta12.url);
+    const __dirname = import_path15.default.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = import_path11.default.join(projectDir, "src");
-    const authFilePath = import_path11.default.join(srcPath, "lib", "auth.ts");
-    if (!import_fs11.default.existsSync(authFilePath)) {
-      console.log(import_chalk11.default.red("No Configured Better Auth file found"));
-      console.log(import_chalk11.default.cyan("Run authverse init to initialize better auth"));
+    const srcPath = import_path15.default.join(projectDir, "src");
+    const authFilePath = import_path15.default.join(srcPath, "lib", "auth.ts");
+    if (!import_fs15.default.existsSync(authFilePath)) {
+      console.log(import_chalk15.default.red("No Configured Better Auth file found"));
+      console.log(import_chalk15.default.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = import_fs11.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs15.default.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(import_chalk11.default.red("betterAuth({}) block not found"));
+      console.log(import_chalk15.default.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("github:")) {
-      console.log(import_chalk11.default.yellow("Github provider already exists"));
+      console.log(import_chalk15.default.yellow("Github provider already exists"));
       return;
     }
     const githubProviderEntry = `
@@ -1520,7 +2057,7 @@ var githubTanstackStart = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(import_chalk11.default.red("Failed to parse socialProviders block"));
+        console.log(import_chalk15.default.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + githubProviderEntry + "\n  " + content.slice(insertPos);
@@ -1528,7 +2065,7 @@ var githubTanstackStart = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          import_chalk11.default.red(
+          import_chalk15.default.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1544,12 +2081,12 @@ ${githubProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    import_fs11.default.writeFileSync(authFilePath, content, "utf8");
-    const envPath = import_path11.default.join(projectDir, ".env");
-    if (import_fs11.default.existsSync(envPath)) {
-      const envContent = import_fs11.default.readFileSync(envPath, "utf8");
+    import_fs15.default.writeFileSync(authFilePath, content, "utf8");
+    const envPath = import_path15.default.join(projectDir, ".env");
+    if (import_fs15.default.existsSync(envPath)) {
+      const envContent = import_fs15.default.readFileSync(envPath, "utf8");
       if (!envContent.includes("GITHUB_CLIENT_ID")) {
-        import_fs11.default.appendFileSync(
+        import_fs15.default.appendFileSync(
           envPath,
           `
 
@@ -1560,53 +2097,53 @@ GITHUB_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = import_path11.default.resolve(
+    const componentTemplate = import_path15.default.resolve(
       __dirname,
       "./template/TanstackStart/components/GithubOAuthButton.tsx"
     );
-    const componentsDir = import_path11.default.join(srcPath, "components", "authverse");
-    if (!import_fs11.default.existsSync(componentsDir)) {
-      import_fs11.default.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = import_path15.default.join(srcPath, "components", "authverse");
+    if (!import_fs15.default.existsSync(componentsDir)) {
+      import_fs15.default.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = import_path11.default.join(componentsDir, "GithubOAuthButton.tsx");
-    if (import_fs11.default.existsSync(componentTemplate)) {
-      import_fs11.default.copyFileSync(componentTemplate, componentDest);
+    const componentDest = import_path15.default.join(componentsDir, "GithubOAuthButton.tsx");
+    if (import_fs15.default.existsSync(componentTemplate)) {
+      import_fs15.default.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(import_chalk11.default.green("Github provider added & merged successfully\n"));
+    console.log(import_chalk15.default.green("Github provider added & merged successfully\n"));
     console.log(
-      import_chalk11.default.white("\u2022 src/components/authverse/GithubOAuthButton.tsx")
+      import_chalk15.default.white("\u2022 src/components/authverse/GithubOAuthButton.tsx")
     );
   } catch (error) {
-    console.log(import_chalk11.default.red("githubRunTanstackState error:"), error);
+    console.log(import_chalk15.default.red("githubRunTanstackState error:"), error);
   }
 };
 
 // oauth/facebookNext.ts
-var import_chalk12 = __toESM(require("chalk"), 1);
-var import_fs12 = __toESM(require("fs"), 1);
-var import_path12 = __toESM(require("path"), 1);
-var import_url11 = require("url");
-var import_meta11 = {};
+var import_chalk16 = __toESM(require("chalk"), 1);
+var import_fs16 = __toESM(require("fs"), 1);
+var import_path16 = __toESM(require("path"), 1);
+var import_url13 = require("url");
+var import_meta13 = {};
 var facebookNext = async () => {
   try {
-    const __filename = (0, import_url11.fileURLToPath)(import_meta11.url);
-    const __dirname = import_path12.default.dirname(__filename);
+    const __filename = (0, import_url13.fileURLToPath)(import_meta13.url);
+    const __dirname = import_path16.default.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = import_path12.default.join(projectDir, "src");
-    const folder = import_fs12.default.existsSync(srcPath) ? "src" : "";
-    const authFilePath = import_path12.default.join(projectDir, folder, "lib", "auth.ts");
-    if (!import_fs12.default.existsSync(authFilePath)) {
-      console.log(import_chalk12.default.red("No Configured Better Auth file found"));
-      console.log(import_chalk12.default.cyan("Run authverse init to initialize better auth"));
+    const srcPath = import_path16.default.join(projectDir, "src");
+    const folder = import_fs16.default.existsSync(srcPath) ? "src" : "";
+    const authFilePath = import_path16.default.join(projectDir, folder, "lib", "auth.ts");
+    if (!import_fs16.default.existsSync(authFilePath)) {
+      console.log(import_chalk16.default.red("No Configured Better Auth file found"));
+      console.log(import_chalk16.default.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = import_fs12.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs16.default.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(import_chalk12.default.red("betterAuth({}) block not found"));
+      console.log(import_chalk16.default.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("facebook:")) {
-      console.log(import_chalk12.default.yellow("Facebook provider already exists"));
+      console.log(import_chalk16.default.yellow("Facebook provider already exists"));
       return;
     }
     const facebookProviderEntry = `
@@ -1629,7 +2166,7 @@ var facebookNext = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(import_chalk12.default.red("Failed to parse socialProviders block"));
+        console.log(import_chalk16.default.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + facebookProviderEntry + "\n  " + content.slice(insertPos);
@@ -1637,7 +2174,7 @@ var facebookNext = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          import_chalk12.default.red(
+          import_chalk16.default.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1653,12 +2190,12 @@ ${facebookProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    import_fs12.default.writeFileSync(authFilePath, content, "utf8");
-    const envPath = import_path12.default.join(projectDir, ".env");
-    if (import_fs12.default.existsSync(envPath)) {
-      const envContent = import_fs12.default.readFileSync(envPath, "utf8");
+    import_fs16.default.writeFileSync(authFilePath, content, "utf8");
+    const envPath = import_path16.default.join(projectDir, ".env");
+    if (import_fs16.default.existsSync(envPath)) {
+      const envContent = import_fs16.default.readFileSync(envPath, "utf8");
       if (!envContent.includes("FACEBOOK_CLIENT_ID")) {
-        import_fs12.default.appendFileSync(
+        import_fs16.default.appendFileSync(
           envPath,
           `
 
@@ -1669,60 +2206,60 @@ FACEBOOK_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = import_path12.default.resolve(
+    const componentTemplate = import_path16.default.resolve(
       __dirname,
       "./template/components/FacebookOAuthButton.tsx"
     );
-    const componentsDir = import_path12.default.join(
+    const componentsDir = import_path16.default.join(
       projectDir,
       folder,
       "components",
       "authverse"
     );
-    if (!import_fs12.default.existsSync(componentsDir)) {
-      import_fs12.default.mkdirSync(componentsDir, { recursive: true });
+    if (!import_fs16.default.existsSync(componentsDir)) {
+      import_fs16.default.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = import_path12.default.join(componentsDir, "FacebookOAuthButton.tsx");
-    if (import_fs12.default.existsSync(componentTemplate)) {
-      import_fs12.default.copyFileSync(componentTemplate, componentDest);
+    const componentDest = import_path16.default.join(componentsDir, "FacebookOAuthButton.tsx");
+    if (import_fs16.default.existsSync(componentTemplate)) {
+      import_fs16.default.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(import_chalk12.default.green("Facebook provider added & merged successfully\n"));
+    console.log(import_chalk16.default.green("Facebook provider added & merged successfully\n"));
     console.log(
-      import_chalk12.default.white(
+      import_chalk16.default.white(
         `${CreateFolder({ srcFolder: folder, destFolder: "components/authverse/FacebookOAuthButton.tsx" })}
 `
       )
     );
   } catch (error) {
-    console.log(import_chalk12.default.red("facebookRun error:"), error);
+    console.log(import_chalk16.default.red("facebookRun error:"), error);
   }
 };
 
 // oauth/facebookTanstackStart.ts
-var import_chalk13 = __toESM(require("chalk"), 1);
-var import_fs13 = __toESM(require("fs"), 1);
-var import_path13 = __toESM(require("path"), 1);
-var import_url12 = require("url");
-var import_meta12 = {};
+var import_chalk17 = __toESM(require("chalk"), 1);
+var import_fs17 = __toESM(require("fs"), 1);
+var import_path17 = __toESM(require("path"), 1);
+var import_url14 = require("url");
+var import_meta14 = {};
 var facebookTanstackStart = async () => {
   try {
-    const __filename = (0, import_url12.fileURLToPath)(import_meta12.url);
-    const __dirname = import_path13.default.dirname(__filename);
+    const __filename = (0, import_url14.fileURLToPath)(import_meta14.url);
+    const __dirname = import_path17.default.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = import_path13.default.join(projectDir, "src");
-    const authFilePath = import_path13.default.join(srcPath, "lib", "auth.ts");
-    if (!import_fs13.default.existsSync(authFilePath)) {
-      console.log(import_chalk13.default.red("No Configured Better Auth file found"));
-      console.log(import_chalk13.default.cyan("Run authverse init to initialize better auth"));
+    const srcPath = import_path17.default.join(projectDir, "src");
+    const authFilePath = import_path17.default.join(srcPath, "lib", "auth.ts");
+    if (!import_fs17.default.existsSync(authFilePath)) {
+      console.log(import_chalk17.default.red("No Configured Better Auth file found"));
+      console.log(import_chalk17.default.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = import_fs13.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs17.default.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(import_chalk13.default.red("betterAuth({}) block not found"));
+      console.log(import_chalk17.default.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("facebook:")) {
-      console.log(import_chalk13.default.yellow("Facebook provider already exists"));
+      console.log(import_chalk17.default.yellow("Facebook provider already exists"));
       return;
     }
     const facebookProviderEntry = `
@@ -1745,7 +2282,7 @@ var facebookTanstackStart = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(import_chalk13.default.red("Failed to parse socialProviders block"));
+        console.log(import_chalk17.default.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + facebookProviderEntry + "\n  " + content.slice(insertPos);
@@ -1753,7 +2290,7 @@ var facebookTanstackStart = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          import_chalk13.default.red(
+          import_chalk17.default.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1769,12 +2306,12 @@ ${facebookProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    import_fs13.default.writeFileSync(authFilePath, content, "utf8");
-    const envPath = import_path13.default.join(projectDir, ".env");
-    if (import_fs13.default.existsSync(envPath)) {
-      const envContent = import_fs13.default.readFileSync(envPath, "utf8");
+    import_fs17.default.writeFileSync(authFilePath, content, "utf8");
+    const envPath = import_path17.default.join(projectDir, ".env");
+    if (import_fs17.default.existsSync(envPath)) {
+      const envContent = import_fs17.default.readFileSync(envPath, "utf8");
       if (!envContent.includes("FACEBOOK_CLIENT_ID")) {
-        import_fs13.default.appendFileSync(
+        import_fs17.default.appendFileSync(
           envPath,
           `
 
@@ -1785,53 +2322,53 @@ FACEBOOK_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = import_path13.default.resolve(
+    const componentTemplate = import_path17.default.resolve(
       __dirname,
       "./template/TanstackStart/components/FacebookOAuthButton.tsx"
     );
-    const componentsDir = import_path13.default.join(srcPath, "components", "authverse");
-    if (!import_fs13.default.existsSync(componentsDir)) {
-      import_fs13.default.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = import_path17.default.join(srcPath, "components", "authverse");
+    if (!import_fs17.default.existsSync(componentsDir)) {
+      import_fs17.default.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = import_path13.default.join(componentsDir, "FacebookOAuthButton.tsx");
-    if (import_fs13.default.existsSync(componentTemplate)) {
-      import_fs13.default.copyFileSync(componentTemplate, componentDest);
+    const componentDest = import_path17.default.join(componentsDir, "FacebookOAuthButton.tsx");
+    if (import_fs17.default.existsSync(componentTemplate)) {
+      import_fs17.default.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(import_chalk13.default.green("Facebook provider added & merged successfully\n"));
+    console.log(import_chalk17.default.green("Facebook provider added & merged successfully\n"));
     console.log(
-      import_chalk13.default.white("\u2022 src/components/authverse/FacebookOAuthButton.tsx")
+      import_chalk17.default.white("\u2022 src/components/authverse/FacebookOAuthButton.tsx")
     );
   } catch (error) {
-    console.log(import_chalk13.default.red("facebookRunTanstackState error:"), error);
+    console.log(import_chalk17.default.red("facebookRunTanstackState error:"), error);
   }
 };
 
 // oauth/LinkedInNext.ts
-var import_chalk14 = __toESM(require("chalk"), 1);
-var import_fs14 = __toESM(require("fs"), 1);
-var import_path14 = __toESM(require("path"), 1);
-var import_url13 = require("url");
-var import_meta13 = {};
+var import_chalk18 = __toESM(require("chalk"), 1);
+var import_fs18 = __toESM(require("fs"), 1);
+var import_path18 = __toESM(require("path"), 1);
+var import_url15 = require("url");
+var import_meta15 = {};
 var LinkedInNext = async () => {
   try {
-    const __filename = (0, import_url13.fileURLToPath)(import_meta13.url);
-    const __dirname = import_path14.default.dirname(__filename);
+    const __filename = (0, import_url15.fileURLToPath)(import_meta15.url);
+    const __dirname = import_path18.default.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = import_path14.default.join(projectDir, "src");
-    const folder = import_fs14.default.existsSync(srcPath) ? "src" : "";
-    const authFilePath = import_path14.default.join(projectDir, folder, "lib", "auth.ts");
-    if (!import_fs14.default.existsSync(authFilePath)) {
-      console.log(import_chalk14.default.red("No Configured Better Auth file found"));
-      console.log(import_chalk14.default.cyan("Run authverse init to initialize better auth"));
+    const srcPath = import_path18.default.join(projectDir, "src");
+    const folder = import_fs18.default.existsSync(srcPath) ? "src" : "";
+    const authFilePath = import_path18.default.join(projectDir, folder, "lib", "auth.ts");
+    if (!import_fs18.default.existsSync(authFilePath)) {
+      console.log(import_chalk18.default.red("No Configured Better Auth file found"));
+      console.log(import_chalk18.default.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = import_fs14.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs18.default.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(import_chalk14.default.red("betterAuth({}) block not found"));
+      console.log(import_chalk18.default.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("LinkedIn:")) {
-      console.log(import_chalk14.default.yellow("LinkedIn provider already exists"));
+      console.log(import_chalk18.default.yellow("LinkedIn provider already exists"));
       return;
     }
     const LinkedInProviderEntry = `
@@ -1854,7 +2391,7 @@ var LinkedInNext = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(import_chalk14.default.red("Failed to parse socialProviders block"));
+        console.log(import_chalk18.default.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + LinkedInProviderEntry + "\n  " + content.slice(insertPos);
@@ -1862,7 +2399,7 @@ var LinkedInNext = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          import_chalk14.default.red(
+          import_chalk18.default.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1878,12 +2415,12 @@ ${LinkedInProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    import_fs14.default.writeFileSync(authFilePath, content, "utf8");
-    const envPath = import_path14.default.join(projectDir, ".env");
-    if (import_fs14.default.existsSync(envPath)) {
-      const envContent = import_fs14.default.readFileSync(envPath, "utf8");
+    import_fs18.default.writeFileSync(authFilePath, content, "utf8");
+    const envPath = import_path18.default.join(projectDir, ".env");
+    if (import_fs18.default.existsSync(envPath)) {
+      const envContent = import_fs18.default.readFileSync(envPath, "utf8");
       if (!envContent.includes("LINKEDIN_CLIENT_ID")) {
-        import_fs14.default.appendFileSync(
+        import_fs18.default.appendFileSync(
           envPath,
           `
 
@@ -1894,60 +2431,60 @@ LINKEDIN_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = import_path14.default.resolve(
+    const componentTemplate = import_path18.default.resolve(
       __dirname,
       "./template/components/LinkedInOAuthButton.tsx"
     );
-    const componentsDir = import_path14.default.join(
+    const componentsDir = import_path18.default.join(
       projectDir,
       folder,
       "components",
       "authverse"
     );
-    if (!import_fs14.default.existsSync(componentsDir)) {
-      import_fs14.default.mkdirSync(componentsDir, { recursive: true });
+    if (!import_fs18.default.existsSync(componentsDir)) {
+      import_fs18.default.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = import_path14.default.join(componentsDir, "LinkedInOAuthButton.tsx");
-    if (import_fs14.default.existsSync(componentTemplate)) {
-      import_fs14.default.copyFileSync(componentTemplate, componentDest);
+    const componentDest = import_path18.default.join(componentsDir, "LinkedInOAuthButton.tsx");
+    if (import_fs18.default.existsSync(componentTemplate)) {
+      import_fs18.default.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(import_chalk14.default.green("LinkedIn provider added & merged successfully\n"));
+    console.log(import_chalk18.default.green("LinkedIn provider added & merged successfully\n"));
     console.log(
-      import_chalk14.default.white(
+      import_chalk18.default.white(
         `${CreateFolder({ srcFolder: folder, destFolder: "components/authverse/LinkedInOAuthButton.tsx" })}
 `
       )
     );
   } catch (error) {
-    console.log(import_chalk14.default.red("LinkedIn error:"), error);
+    console.log(import_chalk18.default.red("LinkedIn error:"), error);
   }
 };
 
 // oauth/LinkedInTanstackStart.ts
-var import_chalk15 = __toESM(require("chalk"), 1);
-var import_fs15 = __toESM(require("fs"), 1);
-var import_path15 = __toESM(require("path"), 1);
-var import_url14 = require("url");
-var import_meta14 = {};
+var import_chalk19 = __toESM(require("chalk"), 1);
+var import_fs19 = __toESM(require("fs"), 1);
+var import_path19 = __toESM(require("path"), 1);
+var import_url16 = require("url");
+var import_meta16 = {};
 var LinkedInTanstackStart = async () => {
   try {
-    const __filename = (0, import_url14.fileURLToPath)(import_meta14.url);
-    const __dirname = import_path15.default.dirname(__filename);
+    const __filename = (0, import_url16.fileURLToPath)(import_meta16.url);
+    const __dirname = import_path19.default.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = import_path15.default.join(projectDir, "src");
-    const authFilePath = import_path15.default.join(srcPath, "lib", "auth.ts");
-    if (!import_fs15.default.existsSync(authFilePath)) {
-      console.log(import_chalk15.default.red("No Configured Better Auth file found"));
-      console.log(import_chalk15.default.cyan("Run authverse init to initialize better auth"));
+    const srcPath = import_path19.default.join(projectDir, "src");
+    const authFilePath = import_path19.default.join(srcPath, "lib", "auth.ts");
+    if (!import_fs19.default.existsSync(authFilePath)) {
+      console.log(import_chalk19.default.red("No Configured Better Auth file found"));
+      console.log(import_chalk19.default.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = import_fs15.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs19.default.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(import_chalk15.default.red("betterAuth({}) block not found"));
+      console.log(import_chalk19.default.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("linkedin:")) {
-      console.log(import_chalk15.default.yellow("LinkedIn provider already exists"));
+      console.log(import_chalk19.default.yellow("LinkedIn provider already exists"));
       return;
     }
     const LinkedInProviderEntry = `
@@ -1970,7 +2507,7 @@ var LinkedInTanstackStart = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(import_chalk15.default.red("Failed to parse socialProviders block"));
+        console.log(import_chalk19.default.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + LinkedInProviderEntry + "\n  " + content.slice(insertPos);
@@ -1978,7 +2515,7 @@ var LinkedInTanstackStart = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          import_chalk15.default.red(
+          import_chalk19.default.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1994,12 +2531,12 @@ ${LinkedInProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    import_fs15.default.writeFileSync(authFilePath, content, "utf8");
-    const envPath = import_path15.default.join(projectDir, ".env");
-    if (import_fs15.default.existsSync(envPath)) {
-      const envContent = import_fs15.default.readFileSync(envPath, "utf8");
+    import_fs19.default.writeFileSync(authFilePath, content, "utf8");
+    const envPath = import_path19.default.join(projectDir, ".env");
+    if (import_fs19.default.existsSync(envPath)) {
+      const envContent = import_fs19.default.readFileSync(envPath, "utf8");
       if (!envContent.includes("LINKEDIN_CLIENT_ID")) {
-        import_fs15.default.appendFileSync(
+        import_fs19.default.appendFileSync(
           envPath,
           `
 
@@ -2010,53 +2547,53 @@ LINKEDIN_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = import_path15.default.resolve(
+    const componentTemplate = import_path19.default.resolve(
       __dirname,
       "./template/TanstackStart/components/LinkedInOAuthButton.tsx"
     );
-    const componentsDir = import_path15.default.join(srcPath, "components", "authverse");
-    if (!import_fs15.default.existsSync(componentsDir)) {
-      import_fs15.default.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = import_path19.default.join(srcPath, "components", "authverse");
+    if (!import_fs19.default.existsSync(componentsDir)) {
+      import_fs19.default.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = import_path15.default.join(componentsDir, "LinkedInOAuthButton.tsx");
-    if (import_fs15.default.existsSync(componentTemplate)) {
-      import_fs15.default.copyFileSync(componentTemplate, componentDest);
+    const componentDest = import_path19.default.join(componentsDir, "LinkedInOAuthButton.tsx");
+    if (import_fs19.default.existsSync(componentTemplate)) {
+      import_fs19.default.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(import_chalk15.default.green("LinkedIn provider added & merged successfully\n"));
+    console.log(import_chalk19.default.green("LinkedIn provider added & merged successfully\n"));
     console.log(
-      import_chalk15.default.white("\u2022 src/components/authverse/LinkedInOAuthButton.tsx")
+      import_chalk19.default.white("\u2022 src/components/authverse/LinkedInOAuthButton.tsx")
     );
   } catch (error) {
-    console.log(import_chalk15.default.red("LinkedInTanstackState error:"), error);
+    console.log(import_chalk19.default.red("LinkedInTanstackState error:"), error);
   }
 };
 
 // oauth/twitterNext.ts
-var import_chalk16 = __toESM(require("chalk"), 1);
-var import_fs16 = __toESM(require("fs"), 1);
-var import_path16 = __toESM(require("path"), 1);
-var import_url15 = require("url");
-var import_meta15 = {};
+var import_chalk20 = __toESM(require("chalk"), 1);
+var import_fs20 = __toESM(require("fs"), 1);
+var import_path20 = __toESM(require("path"), 1);
+var import_url17 = require("url");
+var import_meta17 = {};
 var twitterNext = async () => {
   try {
-    const __filename = (0, import_url15.fileURLToPath)(import_meta15.url);
-    const __dirname = import_path16.default.dirname(__filename);
+    const __filename = (0, import_url17.fileURLToPath)(import_meta17.url);
+    const __dirname = import_path20.default.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = import_path16.default.join(projectDir, "src");
-    const folder = import_fs16.default.existsSync(srcPath) ? "src" : "";
-    const authFilePath = import_path16.default.join(projectDir, folder, "lib", "auth.ts");
-    if (!import_fs16.default.existsSync(authFilePath)) {
-      console.log(import_chalk16.default.red("No Configured Better Auth file found"));
-      console.log(import_chalk16.default.cyan("Run authverse init to initialize better auth"));
+    const srcPath = import_path20.default.join(projectDir, "src");
+    const folder = import_fs20.default.existsSync(srcPath) ? "src" : "";
+    const authFilePath = import_path20.default.join(projectDir, folder, "lib", "auth.ts");
+    if (!import_fs20.default.existsSync(authFilePath)) {
+      console.log(import_chalk20.default.red("No Configured Better Auth file found"));
+      console.log(import_chalk20.default.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = import_fs16.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs20.default.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(import_chalk16.default.red("betterAuth({}) block not found"));
+      console.log(import_chalk20.default.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("twitter:")) {
-      console.log(import_chalk16.default.yellow("twitter provider already exists"));
+      console.log(import_chalk20.default.yellow("twitter provider already exists"));
       return;
     }
     const twitterProviderEntry = `
@@ -2079,7 +2616,7 @@ var twitterNext = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(import_chalk16.default.red("Failed to parse socialProviders block"));
+        console.log(import_chalk20.default.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + twitterProviderEntry + "\n  " + content.slice(insertPos);
@@ -2087,7 +2624,7 @@ var twitterNext = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          import_chalk16.default.red(
+          import_chalk20.default.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -2103,12 +2640,12 @@ ${twitterProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    import_fs16.default.writeFileSync(authFilePath, content, "utf8");
-    const envPath = import_path16.default.join(projectDir, ".env");
-    if (import_fs16.default.existsSync(envPath)) {
-      const envContent = import_fs16.default.readFileSync(envPath, "utf8");
+    import_fs20.default.writeFileSync(authFilePath, content, "utf8");
+    const envPath = import_path20.default.join(projectDir, ".env");
+    if (import_fs20.default.existsSync(envPath)) {
+      const envContent = import_fs20.default.readFileSync(envPath, "utf8");
       if (!envContent.includes("TWITTER_CLIENT_ID")) {
-        import_fs16.default.appendFileSync(
+        import_fs20.default.appendFileSync(
           envPath,
           `
 
@@ -2119,60 +2656,60 @@ TWITTER_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = import_path16.default.resolve(
+    const componentTemplate = import_path20.default.resolve(
       __dirname,
       "./template/components/twitterOAuthButton.tsx"
     );
-    const componentsDir = import_path16.default.join(
+    const componentsDir = import_path20.default.join(
       projectDir,
       folder,
       "components",
       "authverse"
     );
-    if (!import_fs16.default.existsSync(componentsDir)) {
-      import_fs16.default.mkdirSync(componentsDir, { recursive: true });
+    if (!import_fs20.default.existsSync(componentsDir)) {
+      import_fs20.default.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = import_path16.default.join(componentsDir, "twitterOAuthButton.tsx");
-    if (import_fs16.default.existsSync(componentTemplate)) {
-      import_fs16.default.copyFileSync(componentTemplate, componentDest);
+    const componentDest = import_path20.default.join(componentsDir, "twitterOAuthButton.tsx");
+    if (import_fs20.default.existsSync(componentTemplate)) {
+      import_fs20.default.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(import_chalk16.default.green("Twitter provider added & merged successfully\n"));
+    console.log(import_chalk20.default.green("Twitter provider added & merged successfully\n"));
     console.log(
-      import_chalk16.default.white(
+      import_chalk20.default.white(
         `${CreateFolder({ srcFolder: folder, destFolder: "components/authverse/TwitterOAuthButton.tsx" })}
 `
       )
     );
   } catch (error) {
-    console.log(import_chalk16.default.red("twitter error:"), error);
+    console.log(import_chalk20.default.red("twitter error:"), error);
   }
 };
 
 // oauth/twitterTanstackStart.ts
-var import_chalk17 = __toESM(require("chalk"), 1);
-var import_fs17 = __toESM(require("fs"), 1);
-var import_path17 = __toESM(require("path"), 1);
-var import_url16 = require("url");
-var import_meta16 = {};
+var import_chalk21 = __toESM(require("chalk"), 1);
+var import_fs21 = __toESM(require("fs"), 1);
+var import_path21 = __toESM(require("path"), 1);
+var import_url18 = require("url");
+var import_meta18 = {};
 var twitterTanstackStart = async () => {
   try {
-    const __filename = (0, import_url16.fileURLToPath)(import_meta16.url);
-    const __dirname = import_path17.default.dirname(__filename);
+    const __filename = (0, import_url18.fileURLToPath)(import_meta18.url);
+    const __dirname = import_path21.default.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = import_path17.default.join(projectDir, "src");
-    const authFilePath = import_path17.default.join(srcPath, "lib", "auth.ts");
-    if (!import_fs17.default.existsSync(authFilePath)) {
-      console.log(import_chalk17.default.red("No Configured Better Auth file found"));
-      console.log(import_chalk17.default.cyan("Run authverse init to initialize better auth"));
+    const srcPath = import_path21.default.join(projectDir, "src");
+    const authFilePath = import_path21.default.join(srcPath, "lib", "auth.ts");
+    if (!import_fs21.default.existsSync(authFilePath)) {
+      console.log(import_chalk21.default.red("No Configured Better Auth file found"));
+      console.log(import_chalk21.default.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = import_fs17.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs21.default.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(import_chalk17.default.red("betterAuth({}) block not found"));
+      console.log(import_chalk21.default.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("twitter:")) {
-      console.log(import_chalk17.default.yellow("twitter provider already exists"));
+      console.log(import_chalk21.default.yellow("twitter provider already exists"));
       return;
     }
     const twitterProviderEntry = `
@@ -2195,7 +2732,7 @@ var twitterTanstackStart = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(import_chalk17.default.red("Failed to parse socialProviders block"));
+        console.log(import_chalk21.default.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + twitterProviderEntry + "\n  " + content.slice(insertPos);
@@ -2203,7 +2740,7 @@ var twitterTanstackStart = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          import_chalk17.default.red(
+          import_chalk21.default.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -2219,12 +2756,12 @@ ${twitterProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    import_fs17.default.writeFileSync(authFilePath, content, "utf8");
-    const envPath = import_path17.default.join(projectDir, ".env");
-    if (import_fs17.default.existsSync(envPath)) {
-      const envContent = import_fs17.default.readFileSync(envPath, "utf8");
+    import_fs21.default.writeFileSync(authFilePath, content, "utf8");
+    const envPath = import_path21.default.join(projectDir, ".env");
+    if (import_fs21.default.existsSync(envPath)) {
+      const envContent = import_fs21.default.readFileSync(envPath, "utf8");
       if (!envContent.includes("TWITTER_CLIENT_ID")) {
-        import_fs17.default.appendFileSync(
+        import_fs21.default.appendFileSync(
           envPath,
           `
 
@@ -2235,54 +2772,54 @@ TWITTER_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = import_path17.default.resolve(
+    const componentTemplate = import_path21.default.resolve(
       __dirname,
       "./template/TanstackStart/components/twitterOAuthButton.tsx"
     );
-    const componentsDir = import_path17.default.join(srcPath, "components", "authverse");
-    if (!import_fs17.default.existsSync(componentsDir)) {
-      import_fs17.default.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = import_path21.default.join(srcPath, "components", "authverse");
+    if (!import_fs21.default.existsSync(componentsDir)) {
+      import_fs21.default.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = import_path17.default.join(componentsDir, "twitterOAuthButton.tsx");
-    if (import_fs17.default.existsSync(componentTemplate)) {
-      import_fs17.default.copyFileSync(componentTemplate, componentDest);
+    const componentDest = import_path21.default.join(componentsDir, "twitterOAuthButton.tsx");
+    if (import_fs21.default.existsSync(componentTemplate)) {
+      import_fs21.default.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(import_chalk17.default.green("twitter provider added & merged successfully\n"));
+    console.log(import_chalk21.default.green("twitter provider added & merged successfully\n"));
     console.log(
-      import_chalk17.default.white("\u2022 src/components/authverse/twitterOAuthButton.tsx")
+      import_chalk21.default.white("\u2022 src/components/authverse/twitterOAuthButton.tsx")
     );
   } catch (error) {
-    console.log(import_chalk17.default.red("twitter tanstack state error:"), error);
+    console.log(import_chalk21.default.red("twitter tanstack state error:"), error);
   }
 };
 
 // oauth/AppleNext.ts
-var import_chalk18 = __toESM(require("chalk"), 1);
-var import_fs18 = __toESM(require("fs"), 1);
-var import_path18 = __toESM(require("path"), 1);
-var import_url17 = require("url");
-var import_meta17 = {};
+var import_chalk22 = __toESM(require("chalk"), 1);
+var import_fs22 = __toESM(require("fs"), 1);
+var import_path22 = __toESM(require("path"), 1);
+var import_url19 = require("url");
+var import_meta19 = {};
 var AppleNext = async () => {
   try {
-    const __filename = (0, import_url17.fileURLToPath)(import_meta17.url);
-    const __dirname = import_path18.default.dirname(__filename);
+    const __filename = (0, import_url19.fileURLToPath)(import_meta19.url);
+    const __dirname = import_path22.default.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = import_path18.default.join(projectDir, "src");
-    const folder = import_fs18.default.existsSync(srcPath) ? "src" : "";
-    const authFilePath = import_path18.default.join(projectDir, folder, "lib", "auth.ts");
-    if (!import_fs18.default.existsSync(authFilePath)) {
-      console.log(import_chalk18.default.red("No Configured Better Auth file found"));
-      console.log(import_chalk18.default.cyan("Run authverse init to initialize better auth"));
+    const srcPath = import_path22.default.join(projectDir, "src");
+    const folder = import_fs22.default.existsSync(srcPath) ? "src" : "";
+    const authFilePath = import_path22.default.join(projectDir, folder, "lib", "auth.ts");
+    if (!import_fs22.default.existsSync(authFilePath)) {
+      console.log(import_chalk22.default.red("No Configured Better Auth file found"));
+      console.log(import_chalk22.default.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = import_fs18.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs22.default.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(import_chalk18.default.red("betterAuth({}) block not found"));
-      console.log(import_chalk18.default.cyan("Run authverse init to initialize better auth"));
+      console.log(import_chalk22.default.red("betterAuth({}) block not found"));
+      console.log(import_chalk22.default.cyan("Run authverse init to initialize better auth"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("apple:")) {
-      console.log(import_chalk18.default.yellow("Apple provider already exists"));
+      console.log(import_chalk22.default.yellow("Apple provider already exists"));
       return;
     }
     const appleProviderEntry = `
@@ -2307,7 +2844,7 @@ var AppleNext = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(import_chalk18.default.red("Failed to parse socialProviders block"));
+        console.log(import_chalk22.default.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + appleProviderEntry + "\n  " + content.slice(insertPos);
@@ -2315,7 +2852,7 @@ var AppleNext = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          import_chalk18.default.red(
+          import_chalk22.default.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -2345,12 +2882,12 @@ ${socialProvidersBlock}`
         content = content.slice(0, insertPos) + '\n  trustedOrigins: ["https://appleid.apple.com"],' + content.slice(insertPos);
       }
     }
-    import_fs18.default.writeFileSync(authFilePath, content, "utf8");
-    const envPath = import_path18.default.join(projectDir, ".env");
-    if (import_fs18.default.existsSync(envPath)) {
-      const envContent = import_fs18.default.readFileSync(envPath, "utf8");
+    import_fs22.default.writeFileSync(authFilePath, content, "utf8");
+    const envPath = import_path22.default.join(projectDir, ".env");
+    if (import_fs22.default.existsSync(envPath)) {
+      const envContent = import_fs22.default.readFileSync(envPath, "utf8");
       if (!envContent.includes("APPLE_CLIENT_ID")) {
-        import_fs18.default.appendFileSync(
+        import_fs22.default.appendFileSync(
           envPath,
           `
 
@@ -2362,60 +2899,60 @@ APPLE_BUNDLE_ID=
         );
       }
     }
-    const componentTemplate = import_path18.default.resolve(
+    const componentTemplate = import_path22.default.resolve(
       __dirname,
       "./template/components/AppleOAuthButton.tsx"
     );
-    const componentsDir = import_path18.default.join(
+    const componentsDir = import_path22.default.join(
       projectDir,
       folder,
       "components",
       "authverse"
     );
-    if (!import_fs18.default.existsSync(componentsDir)) {
-      import_fs18.default.mkdirSync(componentsDir, { recursive: true });
+    if (!import_fs22.default.existsSync(componentsDir)) {
+      import_fs22.default.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = import_path18.default.join(componentsDir, "AppleOAuthButton.tsx");
-    if (import_fs18.default.existsSync(componentTemplate)) {
-      import_fs18.default.copyFileSync(componentTemplate, componentDest);
+    const componentDest = import_path22.default.join(componentsDir, "AppleOAuthButton.tsx");
+    if (import_fs22.default.existsSync(componentTemplate)) {
+      import_fs22.default.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(import_chalk18.default.green("Apple provider added & merged successfully\n"));
+    console.log(import_chalk22.default.green("Apple provider added & merged successfully\n"));
     console.log(
-      import_chalk18.default.white(
+      import_chalk22.default.white(
         `${CreateFolder({ srcFolder: folder, destFolder: "components/authverse/AppleOAuthButton.tsx" })}
 `
       )
     );
   } catch (error) {
-    console.log(import_chalk18.default.red("apple next error:"), error);
+    console.log(import_chalk22.default.red("apple next error:"), error);
   }
 };
 
 // oauth/AppleTanstackStart.ts
-var import_chalk19 = __toESM(require("chalk"), 1);
-var import_fs19 = __toESM(require("fs"), 1);
-var import_path19 = __toESM(require("path"), 1);
-var import_url18 = require("url");
-var import_meta18 = {};
+var import_chalk23 = __toESM(require("chalk"), 1);
+var import_fs23 = __toESM(require("fs"), 1);
+var import_path23 = __toESM(require("path"), 1);
+var import_url20 = require("url");
+var import_meta20 = {};
 var AppleTanstackStart = async () => {
   try {
-    const __filename = (0, import_url18.fileURLToPath)(import_meta18.url);
-    const __dirname = import_path19.default.dirname(__filename);
+    const __filename = (0, import_url20.fileURLToPath)(import_meta20.url);
+    const __dirname = import_path23.default.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = import_path19.default.join(projectDir, "src");
-    const authFilePath = import_path19.default.join(srcPath, "lib", "auth.ts");
-    if (!import_fs19.default.existsSync(authFilePath)) {
-      console.log(import_chalk19.default.red("No Configured Better Auth file found"));
-      console.log(import_chalk19.default.cyan("Run authverse init to initialize better auth"));
+    const srcPath = import_path23.default.join(projectDir, "src");
+    const authFilePath = import_path23.default.join(srcPath, "lib", "auth.ts");
+    if (!import_fs23.default.existsSync(authFilePath)) {
+      console.log(import_chalk23.default.red("No Configured Better Auth file found"));
+      console.log(import_chalk23.default.cyan("Run authverse init to initialize better auth"));
       return;
     }
-    let content = import_fs19.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs23.default.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(import_chalk19.default.red("betterAuth({}) block not found"));
+      console.log(import_chalk23.default.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("apple:")) {
-      console.log(import_chalk19.default.yellow("Apple provider already exists"));
+      console.log(import_chalk23.default.yellow("Apple provider already exists"));
       return;
     }
     const appleProviderEntry = `
@@ -2440,7 +2977,7 @@ var AppleTanstackStart = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(import_chalk19.default.red("Failed to parse socialProviders block"));
+        console.log(import_chalk23.default.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + appleProviderEntry + "\n  " + content.slice(insertPos);
@@ -2448,7 +2985,7 @@ var AppleTanstackStart = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          import_chalk19.default.red(
+          import_chalk23.default.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -2478,12 +3015,12 @@ ${socialProvidersBlock}`
         content = content.slice(0, insertPos) + '\n  trustedOrigins: ["https://appleid.apple.com"],' + content.slice(insertPos);
       }
     }
-    import_fs19.default.writeFileSync(authFilePath, content, "utf8");
-    const envPath = import_path19.default.join(projectDir, ".env");
-    if (import_fs19.default.existsSync(envPath)) {
-      const envContent = import_fs19.default.readFileSync(envPath, "utf8");
+    import_fs23.default.writeFileSync(authFilePath, content, "utf8");
+    const envPath = import_path23.default.join(projectDir, ".env");
+    if (import_fs23.default.existsSync(envPath)) {
+      const envContent = import_fs23.default.readFileSync(envPath, "utf8");
       if (!envContent.includes("APPLE_CLIENT_ID")) {
-        import_fs19.default.appendFileSync(
+        import_fs23.default.appendFileSync(
           envPath,
           `
 
@@ -2495,22 +3032,22 @@ APPLE_BUNDLE_ID=
         );
       }
     }
-    const componentTemplate = import_path19.default.resolve(
+    const componentTemplate = import_path23.default.resolve(
       __dirname,
       "./template/TanstackStart/components/AppleOAuthButton.tsx"
     );
-    const componentsDir = import_path19.default.join(srcPath, "components", "authverse");
-    if (!import_fs19.default.existsSync(componentsDir)) {
-      import_fs19.default.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = import_path23.default.join(srcPath, "components", "authverse");
+    if (!import_fs23.default.existsSync(componentsDir)) {
+      import_fs23.default.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = import_path19.default.join(componentsDir, "AppleOAuthButton.tsx");
-    if (import_fs19.default.existsSync(componentTemplate)) {
-      import_fs19.default.copyFileSync(componentTemplate, componentDest);
+    const componentDest = import_path23.default.join(componentsDir, "AppleOAuthButton.tsx");
+    if (import_fs23.default.existsSync(componentTemplate)) {
+      import_fs23.default.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(import_chalk19.default.green("Apple provider added & merged successfully\n"));
-    console.log(import_chalk19.default.white("\u2022 src/components/authverse/AppleOAuthButton.tsx"));
+    console.log(import_chalk23.default.green("Apple provider added & merged successfully\n"));
+    console.log(import_chalk23.default.white("\u2022 src/components/authverse/AppleOAuthButton.tsx"));
   } catch (error) {
-    console.log(import_chalk19.default.red("apple tanstack state error:"), error);
+    console.log(import_chalk23.default.red("apple tanstack state error:"), error);
   }
 };
 
@@ -2519,7 +3056,7 @@ var Oauth = async ({ oauth }) => {
   try {
     const { framework, error } = await getFramework();
     if (error) {
-      console.log(import_chalk20.default.red(error));
+      console.log(import_chalk24.default.red(error));
       return;
     }
     if (framework === "Next js" && oauth == "google") {
@@ -2553,461 +3090,465 @@ var Oauth = async ({ oauth }) => {
       await AppleTanstackStart();
     }
     if (oauth !== "google" && oauth !== "github" && oauth !== "facebook" && oauth !== "LinkedIn" && oauth !== "twitter" && oauth !== "apple") {
-      console.log(import_chalk20.default.red("Invalid oauth provider"));
+      console.log(import_chalk24.default.red("Invalid oauth provider"));
       return;
     }
   } catch (error) {
-    console.log(import_chalk20.default.red("Error adding oauth:"), error);
+    console.log(import_chalk24.default.red("Error adding oauth:"), error);
   }
 };
 
 // script/forgetNext.ts
-var import_chalk28 = __toESM(require("chalk"), 1);
-var import_path27 = __toESM(require("path"), 1);
-var import_url25 = require("url");
-var import_fs27 = __toESM(require("fs"), 1);
+var import_chalk32 = __toESM(require("chalk"), 1);
+var import_path31 = __toESM(require("path"), 1);
+var import_url27 = require("url");
+var import_fs31 = __toESM(require("fs"), 1);
 
 // cli/email.ts
-var import_path26 = __toESM(require("path"), 1);
-var import_fs26 = __toESM(require("fs"), 1);
-var import_inquirer4 = __toESM(require("inquirer"), 1);
+var import_path30 = __toESM(require("path"), 1);
+var import_fs30 = __toESM(require("fs"), 1);
+var import_inquirer5 = __toESM(require("inquirer"), 1);
 
 // email/gmailRun.ts
-var import_chalk21 = __toESM(require("chalk"), 1);
-var import_path20 = __toESM(require("path"), 1);
-var import_fs20 = __toESM(require("fs"), 1);
-var import_url19 = require("url");
-var import_meta19 = {};
+var import_chalk25 = __toESM(require("chalk"), 1);
+var import_path24 = __toESM(require("path"), 1);
+var import_fs24 = __toESM(require("fs"), 1);
+var import_url21 = require("url");
+var import_meta21 = {};
 var gmailRun = async () => {
   try {
     const projectDir = process.cwd();
-    const packageJsonPath = import_path20.default.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(import_fs20.default.readFileSync(packageJsonPath, "utf-8"));
-    const srcFolder = import_fs20.default.existsSync(import_path20.default.join(projectDir, "src")) ? "src" : "";
-    const __filename = (0, import_url19.fileURLToPath)(import_meta19.url);
-    const __dirname = import_path20.default.dirname(__filename);
+    const packageJsonPath = import_path24.default.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(import_fs24.default.readFileSync(packageJsonPath, "utf-8"));
+    const srcFolder = import_fs24.default.existsSync(import_path24.default.join(projectDir, "src")) ? "src" : "";
+    const __filename = (0, import_url21.fileURLToPath)(import_meta21.url);
+    const __dirname = import_path24.default.dirname(__filename);
     if (!packageJson2.dependencies?.nodemailer || !packageJson2.devDependencies?.["@types/nodemailer"]) {
-      console.log(import_chalk21.default.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
+      console.log(import_chalk25.default.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
       packageManager("nodemailer");
       packageManager("@types/nodemailer", true);
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(import_chalk21.default.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      console.log(import_chalk25.default.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
       packageManager("@react-email/components");
     }
     if (!packageJson2.dependencies?.["@react-email/render"]) {
-      console.log(import_chalk21.default.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
+      console.log(import_chalk25.default.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
       packageManager("@react-email/render");
     }
-    const envPath = import_path20.default.join(projectDir, ".env");
-    const envContent = import_fs20.default.readFileSync(envPath, "utf8");
+    const envPath = import_path24.default.join(projectDir, ".env");
+    const envContent = import_fs24.default.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")) {
-      import_fs20.default.appendFileSync(envPath, `
+      import_fs24.default.appendFileSync(envPath, `
 
 # Gmail API Key for sending emails`);
-      import_fs20.default.appendFileSync(envPath, `
+      import_fs24.default.appendFileSync(envPath, `
 GMAIL_HOST=`);
-      import_fs20.default.appendFileSync(envPath, `
+      import_fs24.default.appendFileSync(envPath, `
 GMAIL_PORT=`);
-      import_fs20.default.appendFileSync(envPath, `
+      import_fs24.default.appendFileSync(envPath, `
 GMAIL_SERVICE=`);
-      import_fs20.default.appendFileSync(envPath, `
+      import_fs24.default.appendFileSync(envPath, `
 GMAIL_MAIL=`);
-      import_fs20.default.appendFileSync(envPath, `
+      import_fs24.default.appendFileSync(envPath, `
 GMAIL_NAME=`);
-      import_fs20.default.appendFileSync(envPath, `
+      import_fs24.default.appendFileSync(envPath, `
 GMAIL_PASSWORD=`);
     }
-    const templatePath = import_path20.default.resolve(
+    const templatePath = import_path24.default.resolve(
       __dirname,
       "./template/email/emailGmail.ts"
     );
-    const libPath = import_path20.default.join(projectDir, srcFolder, "lib");
-    if (!import_fs20.default.existsSync(libPath)) {
-      import_fs20.default.mkdirSync(libPath, { recursive: true });
+    const libPath = import_path24.default.join(projectDir, srcFolder, "lib");
+    if (!import_fs24.default.existsSync(libPath)) {
+      import_fs24.default.mkdirSync(libPath, { recursive: true });
     }
-    const libDestinationPath = import_path20.default.join(libPath, "email.ts");
-    import_fs20.default.copyFileSync(templatePath, libDestinationPath);
-    console.log(import_chalk21.default.green("\nCompleted installation successfully"));
-    console.log(import_chalk21.default.cyan("\nInstall Package:"));
+    const libDestinationPath = import_path24.default.join(libPath, "email.ts");
+    import_fs24.default.copyFileSync(templatePath, libDestinationPath);
+    console.log(import_chalk25.default.green("\nCompleted installation successfully"));
+    console.log(import_chalk25.default.cyan("\nInstall Package:"));
     console.log(
-      import_chalk21.default.white(
+      import_chalk25.default.white(
         `\u2022 nodemailer
 \u2022 @react-email/components
 \u2022 @react-email/render`
       )
     );
-    console.log(import_chalk21.default.cyan("\nFiles created:"));
+    console.log(import_chalk25.default.cyan("\nFiles created:"));
     console.log(
-      import_chalk21.default.white(
+      import_chalk25.default.white(
         `${CreateFolder({ srcFolder, destFolder: "lib/email.ts" })}
 `
       )
     );
   } catch (error) {
-    console.log(import_chalk21.default.red(error));
+    console.log(import_chalk25.default.red(error));
   }
 };
 
 // email/gmailRunTanstackStart.ts
-var import_chalk22 = __toESM(require("chalk"), 1);
-var import_path21 = __toESM(require("path"), 1);
-var import_fs21 = __toESM(require("fs"), 1);
-var import_url20 = require("url");
-var import_meta20 = {};
+var import_chalk26 = __toESM(require("chalk"), 1);
+var import_path25 = __toESM(require("path"), 1);
+var import_fs25 = __toESM(require("fs"), 1);
+var import_url22 = require("url");
+var import_meta22 = {};
 var gmailRunTanstackStart = async () => {
   try {
     const projectDir = process.cwd();
-    const packageJsonPath = import_path21.default.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(import_fs21.default.readFileSync(packageJsonPath, "utf-8"));
-    const __filename = (0, import_url20.fileURLToPath)(import_meta20.url);
-    const __dirname = import_path21.default.dirname(__filename);
+    const packageJsonPath = import_path25.default.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(import_fs25.default.readFileSync(packageJsonPath, "utf-8"));
+    const __filename = (0, import_url22.fileURLToPath)(import_meta22.url);
+    const __dirname = import_path25.default.dirname(__filename);
     if (!packageJson2.dependencies?.nodemailer || !packageJson2.devDependencies?.["@types/nodemailer"]) {
-      console.log(import_chalk22.default.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
+      console.log(import_chalk26.default.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
       packageManager("nodemailer");
       packageManager("@types/nodemailer", true);
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(import_chalk22.default.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      console.log(import_chalk26.default.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
       packageManager("@react-email/components");
     }
     if (!packageJson2.dependencies?.["@react-email/render"]) {
-      console.log(import_chalk22.default.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
+      console.log(import_chalk26.default.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
       packageManager("@react-email/render");
     }
-    const envPath = import_path21.default.join(projectDir, ".env");
-    const envContent = import_fs21.default.readFileSync(envPath, "utf8");
+    const envPath = import_path25.default.join(projectDir, ".env");
+    const envContent = import_fs25.default.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")) {
-      import_fs21.default.appendFileSync(envPath, `
+      import_fs25.default.appendFileSync(envPath, `
 
 # Gmail API Key for sending emails`);
-      import_fs21.default.appendFileSync(envPath, `
+      import_fs25.default.appendFileSync(envPath, `
 GMAIL_HOST=`);
-      import_fs21.default.appendFileSync(envPath, `
+      import_fs25.default.appendFileSync(envPath, `
 GMAIL_PORT=`);
-      import_fs21.default.appendFileSync(envPath, `
+      import_fs25.default.appendFileSync(envPath, `
 GMAIL_SERVICE=`);
-      import_fs21.default.appendFileSync(envPath, `
+      import_fs25.default.appendFileSync(envPath, `
 GMAIL_MAIL=`);
-      import_fs21.default.appendFileSync(envPath, `
+      import_fs25.default.appendFileSync(envPath, `
 GMAIL_NAME=`);
-      import_fs21.default.appendFileSync(envPath, `
+      import_fs25.default.appendFileSync(envPath, `
 GMAIL_PASSWORD=`);
     }
-    const templatePath = import_path21.default.resolve(
+    const templatePath = import_path25.default.resolve(
       __dirname,
       "./template/email/emailGmail.ts"
     );
-    const libPath = import_path21.default.join(projectDir, "src", "lib");
-    if (!import_fs21.default.existsSync(libPath)) {
-      import_fs21.default.mkdirSync(libPath, { recursive: true });
+    const libPath = import_path25.default.join(projectDir, "src", "lib");
+    if (!import_fs25.default.existsSync(libPath)) {
+      import_fs25.default.mkdirSync(libPath, { recursive: true });
     }
-    const libDestinationPath = import_path21.default.join(libPath, "email.ts");
-    import_fs21.default.copyFileSync(templatePath, libDestinationPath);
-    console.log(import_chalk22.default.green("\nCompleted installation successfully"));
-    console.log(import_chalk22.default.cyan("\nInstall Package:"));
+    const libDestinationPath = import_path25.default.join(libPath, "email.ts");
+    import_fs25.default.copyFileSync(templatePath, libDestinationPath);
+    console.log(import_chalk26.default.green("\nCompleted installation successfully"));
+    console.log(import_chalk26.default.cyan("\nInstall Package:"));
     console.log(
-      import_chalk22.default.white(
+      import_chalk26.default.white(
         `\u2022 nodemailer
 \u2022 @react-email/components
 \u2022 @react-email/render`
       )
     );
-    console.log(import_chalk22.default.cyan("\nFiles created:"));
-    console.log(import_chalk22.default.white("\u2022 src/lib/email.ts\n"));
+    console.log(import_chalk26.default.cyan("\nFiles created:"));
+    console.log(import_chalk26.default.white("\u2022 src/lib/email.ts\n"));
   } catch (error) {
-    console.log(import_chalk22.default.red(error));
+    console.log(import_chalk26.default.red(error));
   }
 };
 
 // email/awsSesRun.ts
-var import_chalk23 = __toESM(require("chalk"), 1);
-var import_path22 = __toESM(require("path"), 1);
-var import_fs22 = __toESM(require("fs"), 1);
-var import_url21 = require("url");
-var import_meta21 = {};
+var import_chalk27 = __toESM(require("chalk"), 1);
+var import_path26 = __toESM(require("path"), 1);
+var import_fs26 = __toESM(require("fs"), 1);
+var import_url23 = require("url");
+var import_meta23 = {};
 var awsSesRun = async () => {
   try {
     const projectDir = process.cwd();
-    const packageJsonPath = import_path22.default.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(import_fs22.default.readFileSync(packageJsonPath, "utf-8"));
-    const srcFolder = import_fs22.default.existsSync(import_path22.default.join(projectDir, "src")) ? "src" : "";
-    const __filename = (0, import_url21.fileURLToPath)(import_meta21.url);
-    const __dirname = import_path22.default.dirname(__filename);
+    const packageJsonPath = import_path26.default.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(import_fs26.default.readFileSync(packageJsonPath, "utf-8"));
+    const srcFolder = import_fs26.default.existsSync(import_path26.default.join(projectDir, "src")) ? "src" : "";
+    const __filename = (0, import_url23.fileURLToPath)(import_meta23.url);
+    const __dirname = import_path26.default.dirname(__filename);
     if (!packageJson2.dependencies?.nodemailer || !packageJson2.devDependencies?.["@types/nodemailer"]) {
-      console.log(import_chalk23.default.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
+      console.log(import_chalk27.default.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
       packageManager("nodemailer");
       packageManager("@types/nodemailer", true);
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(import_chalk23.default.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      console.log(import_chalk27.default.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
       packageManager("@react-email/components");
     }
     if (!packageJson2.dependencies?.["@react-email/render"]) {
-      console.log(import_chalk23.default.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
+      console.log(import_chalk27.default.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
       packageManager("@react-email/render");
     }
-    const envPath = import_path22.default.join(projectDir, ".env");
-    const envContent = import_fs22.default.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")) {
-      import_fs22.default.appendFileSync(envPath, `
+    const envPath = import_path26.default.join(projectDir, ".env");
+    const envContent = import_fs26.default.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")) {
+      import_fs26.default.appendFileSync(envPath, `
 
 # AWS SES API Key for sending emails`);
-      import_fs22.default.appendFileSync(envPath, `
+      import_fs26.default.appendFileSync(envPath, `
 AWS_SES_HOST=`);
-      import_fs22.default.appendFileSync(envPath, `
+      import_fs26.default.appendFileSync(envPath, `
 AWS_SES_PORT=`);
-      import_fs22.default.appendFileSync(envPath, `
+      import_fs26.default.appendFileSync(envPath, `
 AWS_SES_SERVICE=`);
-      import_fs22.default.appendFileSync(envPath, `
+      import_fs26.default.appendFileSync(envPath, `
 AWS_SES_USER=`);
-      import_fs22.default.appendFileSync(envPath, `
+      import_fs26.default.appendFileSync(envPath, `
 AWS_SES_PASS=`);
-      import_fs22.default.appendFileSync(envPath, `
+      import_fs26.default.appendFileSync(envPath, `
 AWS_SES_FROM=`);
+      import_fs26.default.appendFileSync(envPath, `
+AWS_SES_FROM_NAME=`);
     }
-    const templatePath = import_path22.default.resolve(
+    const templatePath = import_path26.default.resolve(
       __dirname,
       "./template/email/emailAwsSes.ts"
     );
-    const libPath = import_path22.default.join(projectDir, srcFolder, "lib");
-    if (!import_fs22.default.existsSync(libPath)) {
-      import_fs22.default.mkdirSync(libPath, { recursive: true });
-    }
-    const libDestinationPath = import_path22.default.join(libPath, "email.ts");
-    import_fs22.default.copyFileSync(templatePath, libDestinationPath);
-    console.log(import_chalk23.default.green("\nCompleted installation successfully"));
-    console.log(import_chalk23.default.cyan("\nInstall Package:"));
+    const libPath = import_path26.default.join(projectDir, srcFolder, "lib");
+    if (!import_fs26.default.existsSync(libPath)) {
+      import_fs26.default.mkdirSync(libPath, { recursive: true });
+    }
+    const libDestinationPath = import_path26.default.join(libPath, "email.ts");
+    import_fs26.default.copyFileSync(templatePath, libDestinationPath);
+    console.log(import_chalk27.default.green("\nCompleted installation successfully"));
+    console.log(import_chalk27.default.cyan("\nInstall Package:"));
     console.log(
-      import_chalk23.default.white(
+      import_chalk27.default.white(
         `\u2022 nodemailer
 \u2022 @react-email/components
 \u2022 @react-email/render`
       )
     );
-    console.log(import_chalk23.default.cyan("\nFiles created:"));
+    console.log(import_chalk27.default.cyan("\nFiles created:"));
     console.log(
-      import_chalk23.default.white(
+      import_chalk27.default.white(
         `${CreateFolder({ srcFolder, destFolder: "lib/email.ts" })}
 `
       )
     );
   } catch (error) {
-    console.log(import_chalk23.default.red(error));
+    console.log(import_chalk27.default.red(error));
   }
 };
 
 // email/awsSesRunTanstackStart.ts
-var import_chalk24 = __toESM(require("chalk"), 1);
-var import_path23 = __toESM(require("path"), 1);
-var import_fs23 = __toESM(require("fs"), 1);
-var import_url22 = require("url");
-var import_meta22 = {};
+var import_chalk28 = __toESM(require("chalk"), 1);
+var import_path27 = __toESM(require("path"), 1);
+var import_fs27 = __toESM(require("fs"), 1);
+var import_url24 = require("url");
+var import_meta24 = {};
 var awsSesRunTanstackStart = async () => {
   try {
     const projectDir = process.cwd();
-    const packageJsonPath = import_path23.default.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(import_fs23.default.readFileSync(packageJsonPath, "utf-8"));
-    const __filename = (0, import_url22.fileURLToPath)(import_meta22.url);
-    const __dirname = import_path23.default.dirname(__filename);
+    const packageJsonPath = import_path27.default.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(import_fs27.default.readFileSync(packageJsonPath, "utf-8"));
+    const __filename = (0, import_url24.fileURLToPath)(import_meta24.url);
+    const __dirname = import_path27.default.dirname(__filename);
     if (!packageJson2.dependencies?.nodemailer || !packageJson2.devDependencies?.["@types/nodemailer"]) {
-      console.log(import_chalk24.default.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
+      console.log(import_chalk28.default.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
       packageManager("nodemailer");
       packageManager("@types/nodemailer", true);
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(import_chalk24.default.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      console.log(import_chalk28.default.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
       packageManager("@react-email/components");
     }
     if (!packageJson2.dependencies?.["@react-email/render"]) {
-      console.log(import_chalk24.default.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
+      console.log(import_chalk28.default.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
       packageManager("@react-email/render");
     }
-    const envPath = import_path23.default.join(projectDir, ".env");
-    const envContent = import_fs23.default.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")) {
-      import_fs23.default.appendFileSync(envPath, `
+    const envPath = import_path27.default.join(projectDir, ".env");
+    const envContent = import_fs27.default.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")) {
+      import_fs27.default.appendFileSync(envPath, `
 
 # AWS SES API Key for sending emails`);
-      import_fs23.default.appendFileSync(envPath, `
+      import_fs27.default.appendFileSync(envPath, `
 AWS_SES_HOST=`);
-      import_fs23.default.appendFileSync(envPath, `
+      import_fs27.default.appendFileSync(envPath, `
 AWS_SES_PORT=`);
-      import_fs23.default.appendFileSync(envPath, `
+      import_fs27.default.appendFileSync(envPath, `
 AWS_SES_SERVICE=`);
-      import_fs23.default.appendFileSync(envPath, `
+      import_fs27.default.appendFileSync(envPath, `
 AWS_SES_USER=`);
-      import_fs23.default.appendFileSync(envPath, `
+      import_fs27.default.appendFileSync(envPath, `
 AWS_SES_PASS=`);
-      import_fs23.default.appendFileSync(envPath, `
+      import_fs27.default.appendFileSync(envPath, `
 AWS_SES_FROM=`);
+      import_fs27.default.appendFileSync(envPath, `
+AWS_SES_FROM_NAME=`);
     }
-    const templatePath = import_path23.default.resolve(
+    const templatePath = import_path27.default.resolve(
       __dirname,
       "./template/email/emailAwsSes.ts"
     );
-    const libPath = import_path23.default.join(projectDir, "src", "lib");
-    if (!import_fs23.default.existsSync(libPath)) {
-      import_fs23.default.mkdirSync(libPath, { recursive: true });
-    }
-    const libDestinationPath = import_path23.default.join(libPath, "email.ts");
-    import_fs23.default.copyFileSync(templatePath, libDestinationPath);
-    console.log(import_chalk24.default.green("\nCompleted installation successfully"));
-    console.log(import_chalk24.default.cyan("\nInstall Package:"));
+    const libPath = import_path27.default.join(projectDir, "src", "lib");
+    if (!import_fs27.default.existsSync(libPath)) {
+      import_fs27.default.mkdirSync(libPath, { recursive: true });
+    }
+    const libDestinationPath = import_path27.default.join(libPath, "email.ts");
+    import_fs27.default.copyFileSync(templatePath, libDestinationPath);
+    console.log(import_chalk28.default.green("\nCompleted installation successfully"));
+    console.log(import_chalk28.default.cyan("\nInstall Package:"));
     console.log(
-      import_chalk24.default.white(
+      import_chalk28.default.white(
         `\u2022 nodemailer
 \u2022 @react-email/components
 \u2022 @react-email/render`
       )
     );
-    console.log(import_chalk24.default.cyan("\nFiles created:"));
-    console.log(import_chalk24.default.white("\u2022 src/lib/email.ts\n"));
+    console.log(import_chalk28.default.cyan("\nFiles created:"));
+    console.log(import_chalk28.default.white("\u2022 src/lib/email.ts\n"));
   } catch (error) {
-    console.log(import_chalk24.default.red(error));
+    console.log(import_chalk28.default.red(error));
   }
 };
 
 // email/resendRun.ts
-var import_chalk25 = __toESM(require("chalk"), 1);
-var import_path24 = __toESM(require("path"), 1);
-var import_fs24 = __toESM(require("fs"), 1);
-var import_url23 = require("url");
-var import_meta23 = {};
+var import_chalk29 = __toESM(require("chalk"), 1);
+var import_path28 = __toESM(require("path"), 1);
+var import_fs28 = __toESM(require("fs"), 1);
+var import_url25 = require("url");
+var import_meta25 = {};
 var resendRun = async () => {
   try {
     const projectDir = process.cwd();
-    const packageJsonPath = import_path24.default.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(import_fs24.default.readFileSync(packageJsonPath, "utf-8"));
-    const srcFolder = import_fs24.default.existsSync(import_path24.default.join(projectDir, "src")) ? "src" : "";
-    const __filename = (0, import_url23.fileURLToPath)(import_meta23.url);
-    const __dirname = import_path24.default.dirname(__filename);
+    const packageJsonPath = import_path28.default.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(import_fs28.default.readFileSync(packageJsonPath, "utf-8"));
+    const srcFolder = import_fs28.default.existsSync(import_path28.default.join(projectDir, "src")) ? "src" : "";
+    const __filename = (0, import_url25.fileURLToPath)(import_meta25.url);
+    const __dirname = import_path28.default.dirname(__filename);
     if (!packageJson2.dependencies?.resend) {
-      console.log(import_chalk25.default.cyan("\n\u2699\uFE0F Installing Resend...\n"));
+      console.log(import_chalk29.default.cyan("\n\u2699\uFE0F Installing Resend...\n"));
       packageManager("resend");
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(import_chalk25.default.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      console.log(import_chalk29.default.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
       packageManager("@react-email/components");
     }
     if (!packageJson2.dependencies?.["@react-email/render"]) {
-      console.log(import_chalk25.default.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
+      console.log(import_chalk29.default.cyan("\n\u2699\uFE0F  Installing @react-email/render...\n"));
       packageManager("@react-email/render");
     }
-    const envPath = import_path24.default.join(projectDir, ".env");
-    const envContent = import_fs24.default.readFileSync(envPath, "utf8");
+    const envPath = import_path28.default.join(projectDir, ".env");
+    const envContent = import_fs28.default.readFileSync(envPath, "utf8");
     if (!envContent.includes("RESEND_API_KEY") && !envContent.includes("EMAIL_SENDER_NAME") && !envContent.includes("EMAIL_SENDER_ADDRESS")) {
-      import_fs24.default.appendFileSync(envPath, `
+      import_fs28.default.appendFileSync(envPath, `
 
 # Resend API Key for sending emails`);
-      import_fs24.default.appendFileSync(envPath, `
+      import_fs28.default.appendFileSync(envPath, `
 RESEND_API_KEY=`);
-      import_fs24.default.appendFileSync(envPath, `
+      import_fs28.default.appendFileSync(envPath, `
 EMAIL_SENDER_NAME=Your Name`);
-      import_fs24.default.appendFileSync(envPath, `
+      import_fs28.default.appendFileSync(envPath, `
 EMAIL_SENDER_ADDRESS=`);
     }
-    const templatePath = import_path24.default.resolve(
+    const templatePath = import_path28.default.resolve(
       __dirname,
       "./template/email/emailResend.ts"
     );
-    const libPath = import_path24.default.join(projectDir, srcFolder, "lib");
-    if (!import_fs24.default.existsSync(libPath)) {
-      import_fs24.default.mkdirSync(libPath, { recursive: true });
-    }
-    const libDestinationPath = import_path24.default.join(libPath, "email.ts");
-    import_fs24.default.copyFileSync(templatePath, libDestinationPath);
-    console.log(import_chalk25.default.green("\nCompleted installation successfully"));
-    console.log(import_chalk25.default.cyan("\nInstall Package:"));
+    const libPath = import_path28.default.join(projectDir, srcFolder, "lib");
+    if (!import_fs28.default.existsSync(libPath)) {
+      import_fs28.default.mkdirSync(libPath, { recursive: true });
+    }
+    const libDestinationPath = import_path28.default.join(libPath, "email.ts");
+    import_fs28.default.copyFileSync(templatePath, libDestinationPath);
+    console.log(import_chalk29.default.green("\nCompleted installation successfully"));
+    console.log(import_chalk29.default.cyan("\nInstall Package:"));
     console.log(
-      import_chalk25.default.white(`\u2022 resend
+      import_chalk29.default.white(`\u2022 resend
 \u2022 @react-email/components
 \u2022 @react-email/render`)
     );
-    console.log(import_chalk25.default.cyan("\nFiles created:"));
+    console.log(import_chalk29.default.cyan("\nFiles created:"));
     console.log(
-      import_chalk25.default.white(
+      import_chalk29.default.white(
         `${CreateFolder({ srcFolder, destFolder: "lib/email.ts" })}
 `
       )
     );
   } catch (error) {
-    console.log(import_chalk25.default.red(error));
+    console.log(import_chalk29.default.red(error));
   }
 };
 
 // email/resendRunTanstackStart.ts
-var import_chalk26 = __toESM(require("chalk"), 1);
-var import_path25 = __toESM(require("path"), 1);
-var import_fs25 = __toESM(require("fs"), 1);
-var import_url24 = require("url");
-var import_meta24 = {};
+var import_chalk30 = __toESM(require("chalk"), 1);
+var import_path29 = __toESM(require("path"), 1);
+var import_fs29 = __toESM(require("fs"), 1);
+var import_url26 = require("url");
+var import_meta26 = {};
 var resendRunTanstackStart = async () => {
   try {
     const projectDir = process.cwd();
-    const packageJsonPath = import_path25.default.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(import_fs25.default.readFileSync(packageJsonPath, "utf-8"));
-    const __filename = (0, import_url24.fileURLToPath)(import_meta24.url);
-    const __dirname = import_path25.default.dirname(__filename);
+    const packageJsonPath = import_path29.default.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(import_fs29.default.readFileSync(packageJsonPath, "utf-8"));
+    const __filename = (0, import_url26.fileURLToPath)(import_meta26.url);
+    const __dirname = import_path29.default.dirname(__filename);
     if (!packageJson2.dependencies?.resend) {
-      console.log(import_chalk26.default.cyan("\n\u2699\uFE0F Installing Resend...\n"));
+      console.log(import_chalk30.default.cyan("\n\u2699\uFE0F Installing Resend...\n"));
       packageManager("resend");
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(import_chalk26.default.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      console.log(import_chalk30.default.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
       packageManager("@react-email/components");
     }
-    const envPath = import_path25.default.join(projectDir, ".env");
-    const envContent = import_fs25.default.readFileSync(envPath, "utf8");
+    const envPath = import_path29.default.join(projectDir, ".env");
+    const envContent = import_fs29.default.readFileSync(envPath, "utf8");
     if (!envContent.includes("RESEND_API_KEY") && !envContent.includes("EMAIL_SENDER_NAME") && !envContent.includes("EMAIL_SENDER_ADDRESS")) {
-      import_fs25.default.appendFileSync(envPath, `
+      import_fs29.default.appendFileSync(envPath, `
 
 # Resend API Key for sending emails`);
-      import_fs25.default.appendFileSync(envPath, `
+      import_fs29.default.appendFileSync(envPath, `
 RESEND_API_KEY=`);
-      import_fs25.default.appendFileSync(envPath, `
+      import_fs29.default.appendFileSync(envPath, `
 EMAIL_SENDER_NAME=Your Name`);
-      import_fs25.default.appendFileSync(envPath, `
+      import_fs29.default.appendFileSync(envPath, `
 EMAIL_SENDER_ADDRESS=`);
     }
-    const templatePath = import_path25.default.resolve(
+    const templatePath = import_path29.default.resolve(
       __dirname,
       "./template/email/emailResend.ts"
     );
-    const libPath = import_path25.default.join(projectDir, "src", "lib");
-    if (!import_fs25.default.existsSync(libPath)) {
-      import_fs25.default.mkdirSync(libPath, { recursive: true });
-    }
-    const libDestinationPath = import_path25.default.join(libPath, "email.ts");
-    import_fs25.default.copyFileSync(templatePath, libDestinationPath);
-    console.log(import_chalk26.default.green("\nCompleted installation successfully"));
-    console.log(import_chalk26.default.cyan("\nInstall Package:"));
+    const libPath = import_path29.default.join(projectDir, "src", "lib");
+    if (!import_fs29.default.existsSync(libPath)) {
+      import_fs29.default.mkdirSync(libPath, { recursive: true });
+    }
+    const libDestinationPath = import_path29.default.join(libPath, "email.ts");
+    import_fs29.default.copyFileSync(templatePath, libDestinationPath);
+    console.log(import_chalk30.default.green("\nCompleted installation successfully"));
+    console.log(import_chalk30.default.cyan("\nInstall Package:"));
     console.log(
-      import_chalk26.default.white(`\u2022 resend
+      import_chalk30.default.white(`\u2022 resend
 \u2022 @react-email/components
 \u2022 @react-email/render`)
     );
-    console.log(import_chalk26.default.cyan("\nFiles created:"));
-    console.log(import_chalk26.default.white("\u2022 src/lib/email.ts\n"));
+    console.log(import_chalk30.default.cyan("\nFiles created:"));
+    console.log(import_chalk30.default.white("\u2022 src/lib/email.ts\n"));
   } catch (error) {
-    console.log(import_chalk26.default.red(error));
+    console.log(import_chalk30.default.red(error));
   }
 };
 
 // cli/email.ts
-var import_chalk27 = __toESM(require("chalk"), 1);
+var import_chalk31 = __toESM(require("chalk"), 1);
 var email = async () => {
   const projectDir = process.cwd();
   const { framework, error } = await getFramework();
   if (error) {
-    console.log(import_chalk27.default.red(error));
+    console.log(import_chalk31.default.red(error));
     return;
   }
   if (framework === "Next js") {
-    const srcFolder = import_fs26.default.existsSync(import_path26.default.join(projectDir, "src")) ? "src" : "";
-    const emailPath = import_path26.default.join(projectDir, srcFolder, "lib", "email.ts");
-    if (import_fs26.default.existsSync(emailPath)) {
-      const answers2 = await import_inquirer4.default.prompt([
+    const srcFolder = import_fs30.default.existsSync(import_path30.default.join(projectDir, "src")) ? "src" : "";
+    const emailPath = import_path30.default.join(projectDir, srcFolder, "lib", "email.ts");
+    if (import_fs30.default.existsSync(emailPath)) {
+      const answers2 = await import_inquirer5.default.prompt([
         {
           type: "confirm",
           name: "overwrite",
@@ -3021,13 +3562,13 @@ var email = async () => {
     }
   }
   if (framework === "tanstack start") {
-    const srcFolderTanstackState = import_path26.default.join(projectDir, "src");
-    const libPathTanstackState = import_path26.default.join(
+    const srcFolderTanstackState = import_path30.default.join(projectDir, "src");
+    const libPathTanstackState = import_path30.default.join(
       srcFolderTanstackState,
       "lib/email.ts"
     );
-    if (import_fs26.default.existsSync(libPathTanstackState)) {
-      const answers2 = await import_inquirer4.default.prompt([
+    if (import_fs30.default.existsSync(libPathTanstackState)) {
+      const answers2 = await import_inquirer5.default.prompt([
         {
           type: "confirm",
           name: "overwrite",
@@ -3040,9 +3581,9 @@ var email = async () => {
       }
     }
   }
-  const answers = await import_inquirer4.default.prompt([
+  const answers = await import_inquirer5.default.prompt([
     {
-      type: "list",
+      type: "select",
       name: "emailProvider",
       message: "Choose Your Email Provider:",
       choices: ["Gmail", "AWS SES", "Resend"]
@@ -3069,24 +3610,24 @@ var email = async () => {
 };
 
 // script/forgetNext.ts
-var import_meta25 = {};
+var import_meta27 = {};
 var forgetNext = async () => {
   try {
     const projectDir = process.cwd();
-    const __filename = (0, import_url25.fileURLToPath)(import_meta25.url);
-    const __dirname = import_path27.default.dirname(__filename);
-    const srcPath = import_path27.default.join(projectDir, "src");
-    const folder = import_fs27.default.existsSync(srcPath) ? "src" : "";
-    const emailFilePath = import_path27.default.join(projectDir, folder, "lib", "email.ts");
-    if (!import_fs27.default.existsSync(emailFilePath)) {
+    const __filename = (0, import_url27.fileURLToPath)(import_meta27.url);
+    const __dirname = import_path31.default.dirname(__filename);
+    const srcPath = import_path31.default.join(projectDir, "src");
+    const folder = import_fs31.default.existsSync(srcPath) ? "src" : "";
+    const emailFilePath = import_path31.default.join(projectDir, folder, "lib", "email.ts");
+    if (!import_fs31.default.existsSync(emailFilePath)) {
       await email();
     }
-    const authFilePath = import_path27.default.join(projectDir, folder, "lib", "auth.ts");
-    if (!import_fs27.default.existsSync(authFilePath)) {
-      console.log(import_chalk28.default.red("auth.ts file not found."));
+    const authFilePath = import_path31.default.join(projectDir, folder, "lib", "auth.ts");
+    if (!import_fs31.default.existsSync(authFilePath)) {
+      console.log(import_chalk32.default.red("auth.ts file not found."));
       return;
     }
-    let content = import_fs27.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs31.default.readFileSync(authFilePath, "utf8");
     const codeAdded = `sendResetPassword: async ({ user, url, token }) => {
       await sendEmail({
         email: user.email!,
@@ -3124,7 +3665,7 @@ var forgetNext = async () => {
         const after = content.substring(emailAndPasswordEnd);
         content = before + `${codeAdded}` + after;
       }
-      import_fs27.default.writeFileSync(authFilePath, content, "utf8");
+      import_fs31.default.writeFileSync(authFilePath, content, "utf8");
       if (!content.includes("import { sendEmail }")) {
         const lastImportIndex = content.lastIndexOf("import");
         const nextLineAfterLastImport = content.indexOf("\n", lastImportIndex) + 1;
@@ -3133,7 +3674,7 @@ var forgetNext = async () => {
         const newImports = `import { sendEmail } from "./email";
 `;
         content = beforeImports + newImports + afterImports;
-        import_fs27.default.writeFileSync(authFilePath, content, "utf8");
+        import_fs31.default.writeFileSync(authFilePath, content, "utf8");
       }
       if (!content.includes("import ForgotPasswordEmail from")) {
         const lastImportIndex = content.lastIndexOf("import");
@@ -3143,97 +3684,97 @@ var forgetNext = async () => {
         const newImports = `import ForgotPasswordEmail from "@/components/email/reset-password";
 `;
         content = beforeImports + newImports + afterImports;
-        import_fs27.default.writeFileSync(authFilePath, content, "utf8");
+        import_fs31.default.writeFileSync(authFilePath, content, "utf8");
       }
-      const componentPath = import_path27.default.resolve(
+      const componentPath = import_path31.default.resolve(
         __dirname,
         "./template/email/reset-password.tsx"
       );
-      const destinationPath = import_path27.default.join(
+      const destinationPath = import_path31.default.join(
         projectDir,
         folder,
         "components",
         "email"
       );
-      if (!import_fs27.default.existsSync(destinationPath)) {
-        import_fs27.default.mkdirSync(destinationPath, { recursive: true });
+      if (!import_fs31.default.existsSync(destinationPath)) {
+        import_fs31.default.mkdirSync(destinationPath, { recursive: true });
       }
-      const emailDestinationPath = import_path27.default.join(
+      const emailDestinationPath = import_path31.default.join(
         destinationPath,
         "reset-password.tsx"
       );
-      if (import_fs27.default.existsSync(componentPath)) {
-        import_fs27.default.copyFileSync(componentPath, emailDestinationPath);
+      if (import_fs31.default.existsSync(componentPath)) {
+        import_fs31.default.copyFileSync(componentPath, emailDestinationPath);
       }
-      const forgetComponentPath = import_path27.default.resolve(
+      const forgetComponentPath = import_path31.default.resolve(
         __dirname,
         "./template/components/ForgetComponent.tsx"
       );
-      const componentsDestinationPath = import_path27.default.join(
+      const componentsDestinationPath = import_path31.default.join(
         projectDir,
         folder,
         "components",
         "authverse"
       );
-      if (!import_fs27.default.existsSync(componentsDestinationPath)) {
-        import_fs27.default.mkdirSync(componentsDestinationPath, { recursive: true });
+      if (!import_fs31.default.existsSync(componentsDestinationPath)) {
+        import_fs31.default.mkdirSync(componentsDestinationPath, { recursive: true });
       }
-      const forgetDestinationPath = import_path27.default.join(
+      const forgetDestinationPath = import_path31.default.join(
         componentsDestinationPath,
         "ForgetComponent.tsx"
       );
-      if (import_fs27.default.existsSync(forgetComponentPath)) {
-        import_fs27.default.copyFileSync(forgetComponentPath, forgetDestinationPath);
+      if (import_fs31.default.existsSync(forgetComponentPath)) {
+        import_fs31.default.copyFileSync(forgetComponentPath, forgetDestinationPath);
       }
-      const resetComponentPath = import_path27.default.resolve(
+      const resetComponentPath = import_path31.default.resolve(
         __dirname,
         "./template/components/ResetComponent.tsx"
       );
-      const resetDestinationPath = import_path27.default.join(
+      const resetDestinationPath = import_path31.default.join(
         componentsDestinationPath,
         "ResetComponent.tsx"
       );
-      if (import_fs27.default.existsSync(resetComponentPath)) {
-        import_fs27.default.copyFileSync(resetComponentPath, resetDestinationPath);
+      if (import_fs31.default.existsSync(resetComponentPath)) {
+        import_fs31.default.copyFileSync(resetComponentPath, resetDestinationPath);
       }
-      const authTemplatePath = import_path27.default.resolve(
+      const authTemplatePath = import_path31.default.resolve(
         __dirname,
         "./template/app-auth-uiDesign"
       );
-      const appDestinationPath = import_path27.default.join(projectDir, folder, "app", "auth");
-      if (!import_fs27.default.existsSync(appDestinationPath)) {
-        import_fs27.default.mkdirSync(appDestinationPath, { recursive: true });
+      const appDestinationPath = import_path31.default.join(projectDir, folder, "app", "auth");
+      if (!import_fs31.default.existsSync(appDestinationPath)) {
+        import_fs31.default.mkdirSync(appDestinationPath, { recursive: true });
       }
-      const forgetDestinationDir = import_path27.default.join(appDestinationPath, "forget");
-      if (!import_fs27.default.existsSync(forgetDestinationDir)) {
-        import_fs27.default.mkdirSync(forgetDestinationDir, { recursive: true });
+      const forgetDestinationDir = import_path31.default.join(appDestinationPath, "forget");
+      if (!import_fs31.default.existsSync(forgetDestinationDir)) {
+        import_fs31.default.mkdirSync(forgetDestinationDir, { recursive: true });
       }
-      const forgetPageDestinationPath = import_path27.default.join(
+      const forgetPageDestinationPath = import_path31.default.join(
         forgetDestinationDir,
         "page.tsx"
       );
-      import_fs27.default.copyFileSync(
+      import_fs31.default.copyFileSync(
         `${authTemplatePath}/forget/page.tsx`,
         forgetPageDestinationPath
       );
-      const resetDestinationDir = import_path27.default.join(
+      const resetDestinationDir = import_path31.default.join(
         appDestinationPath,
         "reset-password"
       );
-      if (!import_fs27.default.existsSync(resetDestinationDir)) {
-        import_fs27.default.mkdirSync(resetDestinationDir, { recursive: true });
+      if (!import_fs31.default.existsSync(resetDestinationDir)) {
+        import_fs31.default.mkdirSync(resetDestinationDir, { recursive: true });
       }
-      const resetPageDestinationPath = import_path27.default.join(
+      const resetPageDestinationPath = import_path31.default.join(
         resetDestinationDir,
         "page.tsx"
       );
-      import_fs27.default.copyFileSync(
+      import_fs31.default.copyFileSync(
         `${authTemplatePath}/reset-password/page.tsx`,
         resetPageDestinationPath
       );
-      console.log(import_chalk28.default.green("\nCompleted installation successfully"));
+      console.log(import_chalk32.default.green("\nCompleted installation successfully"));
       console.log(
-        import_chalk28.default.white(
+        import_chalk32.default.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" })}
@@ -3244,36 +3785,36 @@ ${CreateFolder({ srcFolder: folder, destFolder: "app/auth/reset-password/page.ts
       );
     } else {
       console.log(
-        import_chalk28.default.red("Could not find emailAndPassword configuration in auth.ts")
+        import_chalk32.default.red("Could not find emailAndPassword configuration in auth.ts")
       );
     }
   } catch (error) {
-    console.log(import_chalk28.default.red("Error adding sendResetPassword:"), error);
+    console.log(import_chalk32.default.red("Error adding sendResetPassword:"), error);
   }
 };
 
 // script/forgetTanstack.ts
-var import_chalk29 = __toESM(require("chalk"), 1);
-var import_path28 = __toESM(require("path"), 1);
-var import_url26 = require("url");
-var import_fs28 = __toESM(require("fs"), 1);
-var import_meta26 = {};
+var import_chalk33 = __toESM(require("chalk"), 1);
+var import_path32 = __toESM(require("path"), 1);
+var import_url28 = require("url");
+var import_fs32 = __toESM(require("fs"), 1);
+var import_meta28 = {};
 var forgetTanstack = async () => {
   try {
     const projectDir = process.cwd();
-    const __filename = (0, import_url26.fileURLToPath)(import_meta26.url);
-    const __dirname = import_path28.default.dirname(__filename);
-    const srcPath = import_path28.default.join(projectDir, "src");
-    const emailFilePath = import_path28.default.join(srcPath, "lib", "email.ts");
-    if (!import_fs28.default.existsSync(emailFilePath)) {
+    const __filename = (0, import_url28.fileURLToPath)(import_meta28.url);
+    const __dirname = import_path32.default.dirname(__filename);
+    const srcPath = import_path32.default.join(projectDir, "src");
+    const emailFilePath = import_path32.default.join(srcPath, "lib", "email.ts");
+    if (!import_fs32.default.existsSync(emailFilePath)) {
       await email();
     }
-    const authFilePath = import_path28.default.join(srcPath, "lib", "auth.ts");
-    if (!import_fs28.default.existsSync(authFilePath)) {
-      console.log(import_chalk29.default.red("auth.ts file not found."));
+    const authFilePath = import_path32.default.join(srcPath, "lib", "auth.ts");
+    if (!import_fs32.default.existsSync(authFilePath)) {
+      console.log(import_chalk33.default.red("auth.ts file not found."));
       return;
     }
-    let content = import_fs28.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs32.default.readFileSync(authFilePath, "utf8");
     const codeAdded = `sendResetPassword: async ({ user, url, token }) => {
       await sendEmail({
         email: user.email!,
@@ -3311,7 +3852,7 @@ var forgetTanstack = async () => {
         const after = content.substring(emailAndPasswordEnd);
         content = before + `${codeAdded}` + after;
       }
-      import_fs28.default.writeFileSync(authFilePath, content, "utf8");
+      import_fs32.default.writeFileSync(authFilePath, content, "utf8");
       if (!content.includes("import { sendEmail }")) {
         const lastImportIndex = content.lastIndexOf("import");
         const nextLineAfterLastImport = content.indexOf("\n", lastImportIndex) + 1;
@@ -3320,7 +3861,7 @@ var forgetTanstack = async () => {
         const newImports = `import { sendEmail } from "./email";
 `;
         content = beforeImports + newImports + afterImports;
-        import_fs28.default.writeFileSync(authFilePath, content, "utf8");
+        import_fs32.default.writeFileSync(authFilePath, content, "utf8");
       }
       if (!content.includes("import ForgotPasswordEmail from")) {
         const lastImportIndex = content.lastIndexOf("import");
@@ -3330,80 +3871,80 @@ var forgetTanstack = async () => {
         const newImports = `import ForgotPasswordEmail from "@/components/email/reset-password";
 `;
         content = beforeImports + newImports + afterImports;
-        import_fs28.default.writeFileSync(authFilePath, content, "utf8");
+        import_fs32.default.writeFileSync(authFilePath, content, "utf8");
       }
-      const componentPath = import_path28.default.resolve(
+      const componentPath = import_path32.default.resolve(
         __dirname,
         "./template/email/reset-password.tsx"
       );
-      const destinationPath = import_path28.default.join(srcPath, "components", "email");
-      if (!import_fs28.default.existsSync(destinationPath)) {
-        import_fs28.default.mkdirSync(destinationPath, { recursive: true });
+      const destinationPath = import_path32.default.join(srcPath, "components", "email");
+      if (!import_fs32.default.existsSync(destinationPath)) {
+        import_fs32.default.mkdirSync(destinationPath, { recursive: true });
       }
-      const emailDestinationPath = import_path28.default.join(
+      const emailDestinationPath = import_path32.default.join(
         destinationPath,
         "reset-password.tsx"
       );
-      if (import_fs28.default.existsSync(componentPath)) {
-        import_fs28.default.copyFileSync(componentPath, emailDestinationPath);
+      if (import_fs32.default.existsSync(componentPath)) {
+        import_fs32.default.copyFileSync(componentPath, emailDestinationPath);
       }
-      const forgetComponentPath = import_path28.default.resolve(
+      const forgetComponentPath = import_path32.default.resolve(
         __dirname,
         "./template/TanstackStart/components/ForgetComponent.tsx"
       );
-      const componentsDestinationPath = import_path28.default.join(
+      const componentsDestinationPath = import_path32.default.join(
         srcPath,
         "components",
         "authverse"
       );
-      if (!import_fs28.default.existsSync(componentsDestinationPath)) {
-        import_fs28.default.mkdirSync(componentsDestinationPath, { recursive: true });
+      if (!import_fs32.default.existsSync(componentsDestinationPath)) {
+        import_fs32.default.mkdirSync(componentsDestinationPath, { recursive: true });
       }
-      const forgetDestinationPath = import_path28.default.join(
+      const forgetDestinationPath = import_path32.default.join(
         componentsDestinationPath,
         "ForgetComponent.tsx"
       );
-      if (import_fs28.default.existsSync(forgetComponentPath)) {
-        import_fs28.default.copyFileSync(forgetComponentPath, forgetDestinationPath);
+      if (import_fs32.default.existsSync(forgetComponentPath)) {
+        import_fs32.default.copyFileSync(forgetComponentPath, forgetDestinationPath);
       }
-      const resetComponentPath = import_path28.default.resolve(
+      const resetComponentPath = import_path32.default.resolve(
         __dirname,
         "./template/TanstackStart/components/ResetComponent.tsx"
       );
-      const resetDestinationPath = import_path28.default.join(
+      const resetDestinationPath = import_path32.default.join(
         componentsDestinationPath,
         "ResetComponent.tsx"
       );
-      if (import_fs28.default.existsSync(resetComponentPath)) {
-        import_fs28.default.copyFileSync(resetComponentPath, resetDestinationPath);
+      if (import_fs32.default.existsSync(resetComponentPath)) {
+        import_fs32.default.copyFileSync(resetComponentPath, resetDestinationPath);
       }
-      const authTemplatePath = import_path28.default.resolve(
+      const authTemplatePath = import_path32.default.resolve(
         __dirname,
         "./template/TanstackStart/routes/auth"
       );
-      const routesDestinationPath = import_path28.default.join(srcPath, "routes", "auth");
-      if (!import_fs28.default.existsSync(routesDestinationPath)) {
-        import_fs28.default.mkdirSync(routesDestinationPath, { recursive: true });
+      const routesDestinationPath = import_path32.default.join(srcPath, "routes", "auth");
+      if (!import_fs32.default.existsSync(routesDestinationPath)) {
+        import_fs32.default.mkdirSync(routesDestinationPath, { recursive: true });
       }
-      const forgetPageDestinationPath = import_path28.default.join(
+      const forgetPageDestinationPath = import_path32.default.join(
         routesDestinationPath,
         "forget.tsx"
       );
-      import_fs28.default.copyFileSync(
+      import_fs32.default.copyFileSync(
         `${authTemplatePath}/forget.tsx`,
         forgetPageDestinationPath
       );
-      const resetPageDestinationPath = import_path28.default.join(
+      const resetPageDestinationPath = import_path32.default.join(
         routesDestinationPath,
         "reset-password.tsx"
       );
-      import_fs28.default.copyFileSync(
+      import_fs32.default.copyFileSync(
         `${authTemplatePath}/reset-password.tsx`,
         resetPageDestinationPath
       );
-      console.log(import_chalk29.default.green("\nCompleted installation successfully"));
+      console.log(import_chalk33.default.green("\nCompleted installation successfully"));
       console.log(
-        import_chalk29.default.white(
+        import_chalk33.default.white(
           `\u2022 src/components/authverse/ForgetComponent.tsx
 \u2022 src/components/authverse/ResetComponent.tsx
 \u2022 src/components/email/reset-password.tsx
@@ -3414,20 +3955,20 @@ var forgetTanstack = async () => {
       );
     } else {
       console.log(
-        import_chalk29.default.red("Could not find emailAndPassword configuration in auth.ts")
+        import_chalk33.default.red("Could not find emailAndPassword configuration in auth.ts")
       );
     }
   } catch (error) {
-    console.log(import_chalk29.default.red("Error adding sendResetPassword:"), error);
+    console.log(import_chalk33.default.red("Error adding sendResetPassword:"), error);
   }
 };
 
 // cli/forget.ts
-var import_chalk30 = __toESM(require("chalk"), 1);
+var import_chalk34 = __toESM(require("chalk"), 1);
 var forget = async () => {
   const { framework, error } = await getFramework();
   if (error) {
-    console.log(import_chalk30.default.red(error));
+    console.log(import_chalk34.default.red(error));
     return;
   }
   if (framework === "Next js") {
@@ -3439,31 +3980,31 @@ var forget = async () => {
 };
 
 // cli/verification.ts
-var import_chalk33 = __toESM(require("chalk"), 1);
+var import_chalk37 = __toESM(require("chalk"), 1);
 
 // script/verifyNext.ts
-var import_chalk31 = __toESM(require("chalk"), 1);
-var import_fs29 = __toESM(require("fs"), 1);
-var import_path29 = __toESM(require("path"), 1);
-var import_url27 = require("url");
-var import_meta27 = {};
+var import_chalk35 = __toESM(require("chalk"), 1);
+var import_fs33 = __toESM(require("fs"), 1);
+var import_path33 = __toESM(require("path"), 1);
+var import_url29 = require("url");
+var import_meta29 = {};
 var verifyNext = async () => {
   try {
     const projectDir = process.cwd();
-    const __filename = (0, import_url27.fileURLToPath)(import_meta27.url);
-    const __dirname = import_path29.default.dirname(__filename);
-    const srcPath = import_path29.default.join(projectDir, "src");
-    const folder = import_fs29.default.existsSync(srcPath) ? "src" : "";
-    const emailFilePath = import_path29.default.join(projectDir, folder, "lib", "email.ts");
-    if (!import_fs29.default.existsSync(emailFilePath)) {
+    const __filename = (0, import_url29.fileURLToPath)(import_meta29.url);
+    const __dirname = import_path33.default.dirname(__filename);
+    const srcPath = import_path33.default.join(projectDir, "src");
+    const folder = import_fs33.default.existsSync(srcPath) ? "src" : "";
+    const emailFilePath = import_path33.default.join(projectDir, folder, "lib", "email.ts");
+    if (!import_fs33.default.existsSync(emailFilePath)) {
       await email();
     }
-    const authFilePath = import_path29.default.join(projectDir, folder, "lib", "auth.ts");
-    if (!import_fs29.default.existsSync(authFilePath)) {
-      console.log(import_chalk31.default.red("auth.ts file not found."));
+    const authFilePath = import_path33.default.join(projectDir, folder, "lib", "auth.ts");
+    if (!import_fs33.default.existsSync(authFilePath)) {
+      console.log(import_chalk35.default.red("auth.ts file not found."));
       return;
     }
-    let content = import_fs29.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs33.default.readFileSync(authFilePath, "utf8");
     if (content.includes("emailAndPassword: {")) {
       const start = content.indexOf("emailAndPassword: {");
       let end = start;
@@ -3523,52 +4064,52 @@ var verifyNext = async () => {
 `;
       content = content.slice(0, nextLine) + imports + content.slice(nextLine);
     }
-    import_fs29.default.writeFileSync(authFilePath, content, "utf8");
-    const templatePath = import_path29.default.resolve(
+    import_fs33.default.writeFileSync(authFilePath, content, "utf8");
+    const templatePath = import_path33.default.resolve(
       __dirname,
       "./template/email/EmailVerification.tsx"
     );
-    const componentsDir = import_path29.default.join(projectDir, folder, "components", "email");
-    if (!import_fs29.default.existsSync(componentsDir)) {
-      import_fs29.default.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = import_path33.default.join(projectDir, folder, "components", "email");
+    if (!import_fs33.default.existsSync(componentsDir)) {
+      import_fs33.default.mkdirSync(componentsDir, { recursive: true });
     }
-    const destFile = import_path29.default.join(componentsDir, "EmailVerification.tsx");
-    if (import_fs29.default.existsSync(templatePath) && !import_fs29.default.existsSync(destFile)) {
-      import_fs29.default.copyFileSync(templatePath, destFile);
+    const destFile = import_path33.default.join(componentsDir, "EmailVerification.tsx");
+    if (import_fs33.default.existsSync(templatePath) && !import_fs33.default.existsSync(destFile)) {
+      import_fs33.default.copyFileSync(templatePath, destFile);
     }
-    console.log(import_chalk31.default.green("\nCompleted installation successfully"));
+    console.log(import_chalk35.default.green("\nCompleted installation successfully"));
     console.log(
-      import_chalk31.default.white(
+      import_chalk35.default.white(
         `${CreateFolder({ srcFolder: folder, destFolder: "components/email/EmailVerification.tsx" })}`
       )
     );
   } catch (error) {
-    console.log(import_chalk31.default.red(String(error)));
+    console.log(import_chalk35.default.red(String(error)));
   }
 };
 
 // script/verifyTanstack.ts
-var import_chalk32 = __toESM(require("chalk"), 1);
-var import_fs30 = __toESM(require("fs"), 1);
-var import_path30 = __toESM(require("path"), 1);
-var import_url28 = require("url");
-var import_meta28 = {};
+var import_chalk36 = __toESM(require("chalk"), 1);
+var import_fs34 = __toESM(require("fs"), 1);
+var import_path34 = __toESM(require("path"), 1);
+var import_url30 = require("url");
+var import_meta30 = {};
 var verifyTanstack = async () => {
   try {
     const projectDir = process.cwd();
-    const __filename = (0, import_url28.fileURLToPath)(import_meta28.url);
-    const __dirname = import_path30.default.dirname(__filename);
-    const srcPath = import_path30.default.join(projectDir, "src");
-    const emailFilePath = import_path30.default.join(srcPath, "lib", "email.ts");
-    if (!import_fs30.default.existsSync(emailFilePath)) {
+    const __filename = (0, import_url30.fileURLToPath)(import_meta30.url);
+    const __dirname = import_path34.default.dirname(__filename);
+    const srcPath = import_path34.default.join(projectDir, "src");
+    const emailFilePath = import_path34.default.join(srcPath, "lib", "email.ts");
+    if (!import_fs34.default.existsSync(emailFilePath)) {
       await email();
     }
-    const authFilePath = import_path30.default.join(srcPath, "lib", "auth.ts");
-    if (!import_fs30.default.existsSync(authFilePath)) {
-      console.log(import_chalk32.default.red("auth.ts file not found."));
+    const authFilePath = import_path34.default.join(srcPath, "lib", "auth.ts");
+    if (!import_fs34.default.existsSync(authFilePath)) {
+      console.log(import_chalk36.default.red("auth.ts file not found."));
       return;
     }
-    let content = import_fs30.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs34.default.readFileSync(authFilePath, "utf8");
     if (content.includes("emailAndPassword: {")) {
       const start = content.indexOf("emailAndPassword: {");
       let end = start;
@@ -3628,23 +4169,23 @@ var verifyTanstack = async () => {
 `;
       content = content.slice(0, nextLine) + imports + content.slice(nextLine);
     }
-    import_fs30.default.writeFileSync(authFilePath, content, "utf8");
-    const templatePath = import_path30.default.resolve(
+    import_fs34.default.writeFileSync(authFilePath, content, "utf8");
+    const templatePath = import_path34.default.resolve(
       __dirname,
       "./template/email/EmailVerification.tsx"
     );
-    const componentsDir = import_path30.default.join(srcPath, "components", "email");
-    if (!import_fs30.default.existsSync(componentsDir)) {
-      import_fs30.default.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = import_path34.default.join(srcPath, "components", "email");
+    if (!import_fs34.default.existsSync(componentsDir)) {
+      import_fs34.default.mkdirSync(componentsDir, { recursive: true });
     }
-    const destFile = import_path30.default.join(componentsDir, "EmailVerification.tsx");
-    if (import_fs30.default.existsSync(templatePath) && !import_fs30.default.existsSync(destFile)) {
-      import_fs30.default.copyFileSync(templatePath, destFile);
+    const destFile = import_path34.default.join(componentsDir, "EmailVerification.tsx");
+    if (import_fs34.default.existsSync(templatePath) && !import_fs34.default.existsSync(destFile)) {
+      import_fs34.default.copyFileSync(templatePath, destFile);
     }
-    console.log(import_chalk32.default.green("\nCompleted installation successfully"));
-    console.log(import_chalk32.default.white(`\u2022 src/components/email/EmailVerification.tsx`));
+    console.log(import_chalk36.default.green("\nCompleted installation successfully"));
+    console.log(import_chalk36.default.white(`\u2022 src/components/email/EmailVerification.tsx`));
   } catch (error) {
-    console.log(import_chalk32.default.red(String(error)));
+    console.log(import_chalk36.default.red(String(error)));
   }
 };
 
@@ -3653,7 +4194,7 @@ var verification = async () => {
   try {
     const { framework, error } = await getFramework();
     if (error) {
-      console.log(import_chalk33.default.red(error));
+      console.log(import_chalk37.default.red(error));
       return;
     }
     if (framework === "Next js") {
@@ -3663,17 +4204,17 @@ var verification = async () => {
       await verifyTanstack();
     }
   } catch (error) {
-    console.log(import_chalk33.default.red(error.message));
+    console.log(import_chalk37.default.red(error.message));
   }
 };
 
 // cli/initCmd.ts
-var import_chalk34 = __toESM(require("chalk"), 1);
+var import_chalk38 = __toESM(require("chalk"), 1);
 var initCmd = async (cmd) => {
   try {
     const { framework, error } = await getFramework();
     if (error) {
-      console.log(import_chalk34.default.red(error));
+      console.log(import_chalk38.default.red(error));
       return;
     }
     if (framework === "Next js" && cmd.orm === "prisma") {
@@ -3703,12 +4244,12 @@ var initCmd = async (cmd) => {
       });
     }
   } catch (error) {
-    console.log(import_chalk34.default.red(error));
+    console.log(import_chalk38.default.red(error));
   }
 };
 
 // index.ts
-var packageJson = JSON.parse((0, import_fs31.readFileSync)("./package.json", "utf8"));
+var packageJson = JSON.parse((0, import_fs35.readFileSync)("./package.json", "utf8"));
 var program = new import_commander.Command();
 program.name("authverse").description("CLI tool for creating authverse projects").version(
   packageJson.version || "1.0.0",