authverse 1.0.7-canary.1 → 1.0.7

package/dist/index.cjs

@@ -434,8 +434,345 @@ BETTER_AUTH_URL=http://localhost:3000
   }
 };
 
+// cli/init.ts
+var import_path7 = __toESM(require("path"), 1);
+var import_fs7 = __toESM(require("fs"), 1);
+
+// script/prismaRunTanstackState.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);
+
+// 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 authUiTanstackState = async () => {
+  try {
+    console.log(import_chalk4.default.yellow("\n Installing shadcn ui Components\n"));
+    runCommand("shadcn@latest add button sonner card field input");
+    packageManager("@tanstack/react-form");
+    const __filename = (0, import_url4.fileURLToPath)(import_meta4.url);
+    const __dirname = import_path4.default.dirname(__filename);
+    const projectDir = process.cwd();
+    const srcPath = import_path4.default.join(projectDir, "src");
+    const componentPath = import_path4.default.resolve(
+      __dirname,
+      "./template/TanstackState/components"
+    );
+    const authversePathComponents = import_path4.default.join(
+      srcPath,
+      "components",
+      "authverse"
+    );
+    if (!import_fs4.default.existsSync(authversePathComponents)) {
+      import_fs4.default.mkdirSync(authversePathComponents, { recursive: true });
+    }
+    import_fs4.default.copyFileSync(
+      `${componentPath}/LoginComponent.tsx`,
+      import_path4.default.join(authversePathComponents, "LoginComponent.tsx")
+    );
+    import_fs4.default.copyFileSync(
+      `${componentPath}/SingUpComponent.tsx`,
+      import_path4.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 templateRoutesPage = import_path4.default.resolve(
+      __dirname,
+      "./template/TanstackState/routes/auth"
+    );
+    import_fs4.default.copyFileSync(
+      `${templateRoutesPage}/login.tsx`,
+      import_path4.default.join(pageRoutesPath, "login.tsx")
+    );
+    import_fs4.default.copyFileSync(
+      `${templateRoutesPage}/signup.tsx`,
+      import_path4.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");
+      if (!rootContent.includes("Toaster")) {
+        rootContent = `import { Toaster } from "@/components/ui/sonner";
+${rootContent}`;
+      }
+      if (!rootContent.includes("<Toaster")) {
+        rootContent = rootContent.replace(
+          /<\/body>/,
+          "    <Toaster />\n  </body>"
+        );
+      }
+      import_fs4.default.writeFileSync(rootPath, rootContent, "utf-8");
+    }
+    console.log(import_chalk4.default.green("\nSetup completed!\n"));
+  } catch (error) {
+    console.log(import_chalk4.default.red("Auth Ui Tanstack State Error: ", error));
+  }
+};
+
+// script/prismaRunTanstackState.ts
+var import_meta5 = {};
+var prismaRunTanstackState = async ({
+  authUi,
+  database
+}) => {
+  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"));
+    if (!packageJson2.devDependencies?.prisma && !packageJson2.dependencies?.["@prisma/client"]) {
+      console.log(import_chalk5.default.cyan("\n\u2699\uFE0F  Initializing Prisma...\n"));
+      if (database !== "Mongodb") {
+        packageManager("prisma", true);
+        packageManager("@prisma/client");
+        if (database === "Mysql") {
+          packageManager("@prisma/adapter-mariadb");
+        }
+        if (database === "Postgresql") {
+          packageManager("@prisma/adapter-pg");
+        }
+      } else if (database === "Mongodb") {
+        packageManager("prisma@6.19.0", true);
+        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"));
+      runCommand("prisma init");
+      const templatePath = import_path5.default.resolve(
+        __dirname,
+        `./template/prisma/${database}/schema.prisma`
+      );
+      if (!import_fs5.default.existsSync(prismaDir)) {
+        import_fs5.default.mkdirSync(prismaDir, { recursive: true });
+      }
+      const destinationPath = import_path5.default.join(prismaDir, "schema.prisma");
+      import_fs5.default.copyFileSync(templatePath, destinationPath);
+      if (database === "Mongodb") {
+        const prismaConfigPath = import_path5.default.resolve(
+          __dirname,
+          `./template/config/prisma.config.ts`
+        );
+        const prismaConfigDestinationPath = import_path5.default.join("", "prisma.config.ts");
+        import_fs5.default.copyFileSync(prismaConfigPath, prismaConfigDestinationPath);
+      }
+    } else {
+      const schemaPath = import_path5.default.join(prismaDir, "schema.prisma");
+      const schemaContent = import_fs5.default.readFileSync(schemaPath, "utf-8");
+      if (!schemaContent.includes("User") && !schemaContent.includes("Session") && !schemaContent.includes("Account") && !schemaContent.includes("Verification")) {
+        const templatePath = import_path5.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));
+      }
+    }
+    if (!packageJson2.dependencies?.["better-auth"]) {
+      console.log(import_chalk5.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");
+    if (!envContent.includes("BETTER_AUTH_SECRET")) {
+      import_fs5.default.appendFileSync(envPath, `
+
+BETTER_AUTH_SECRET=${secret}`);
+    }
+    if (!envContent.includes("BETTER_AUTH_URL")) {
+      import_fs5.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 authTemplatePath = import_path5.default.resolve(
+      __dirname,
+      `./template/TanstackState/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(
+      __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 authMiddlewareTemplatePath = import_path5.default.resolve(
+      __dirname,
+      `./template/TanstackState/middleware/auth.ts`
+    );
+    const authMiddlewareDestinationPath = import_path5.default.join(middlewarePath, "auth.ts");
+    import_fs5.default.copyFileSync(authMiddlewareTemplatePath, authMiddlewareDestinationPath);
+    const fileRouteTemplatePath = import_path5.default.resolve(
+      __dirname,
+      `./template/TanstackState/routes/$.ts`
+    );
+    const fileRouteDestinationPath = import_path5.default.join(
+      srcPath,
+      "routes",
+      "api",
+      "auth"
+    );
+    if (!import_fs5.default.existsSync(fileRouteDestinationPath)) {
+      import_fs5.default.mkdirSync(fileRouteDestinationPath, { recursive: true });
+    }
+    const apiDestinationPath = import_path5.default.join(fileRouteDestinationPath, "$.ts");
+    import_fs5.default.copyFileSync(fileRouteTemplatePath, apiDestinationPath);
+    if (authUi) {
+      await authUiTanstackState();
+    } else {
+      console.log(
+        import_chalk5.default.green(
+          "\nPrisma setup completed successfully and better-auth installed\n"
+        )
+      );
+    }
+  } catch (err) {
+    console.log(import_chalk5.default.red("Prisma Run Tanstack State Error: ", err));
+  }
+};
+
+// script/drizzleRunTanstackState.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 drizzleRunTanstackState = async (authUi) => {
+  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"));
+    if (!packageJson2.dependencies["better-auth"]) {
+      console.log(import_chalk6.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"));
+      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 secret = await GenerateSecret();
+    const envContent = import_fs6.default.readFileSync(envPath, "utf-8");
+    if (!envContent.includes("BETTER_AUTH_SECRET")) {
+      import_fs6.default.appendFileSync(envPath, `
+
+BETTER_AUTH_SECRET=${secret}`);
+    }
+    if (!envContent.includes("BETTER_AUTH_URL")) {
+      import_fs6.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 authTemplatePath = import_path6.default.resolve(
+      __dirname,
+      "./template/TanstackState/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(
+      __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(
+      __dirname,
+      "./template/config/drizzle.config.ts"
+    );
+    const drizzleConfigDestinationPath = import_path6.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 });
+    }
+    const authMiddlewareTemplatePath = import_path6.default.resolve(
+      __dirname,
+      `./template/TanstackState/middleware/auth.ts`
+    );
+    const authMiddlewareDestinationPath = import_path6.default.join(middlewarePath, "auth.ts");
+    import_fs6.default.copyFileSync(authMiddlewareTemplatePath, authMiddlewareDestinationPath);
+    const fileRouteTemplatePath = import_path6.default.resolve(
+      __dirname,
+      `./template/TanstackState/routes/$.ts`
+    );
+    const fileRouteDestinationPath = import_path6.default.join(
+      srcPath,
+      "routes",
+      "api",
+      "auth"
+    );
+    if (!import_fs6.default.existsSync(fileRouteDestinationPath)) {
+      import_fs6.default.mkdirSync(fileRouteDestinationPath, { recursive: true });
+    }
+    const apiDestinationPath = import_path6.default.join(fileRouteDestinationPath, "$.ts");
+    import_fs6.default.copyFileSync(fileRouteTemplatePath, apiDestinationPath);
+    if (authUi) {
+      await authUiTanstackState();
+    } else {
+      console.log(
+        import_chalk6.default.green(
+          "\nDrizzle setup completed successfully and better-auth installed\n"
+        )
+      );
+    }
+  } catch (err) {
+    console.error(import_chalk6.default.red("Drizzle setup failed:"), err);
+  }
+};
+
 // cli/init.ts
 var initAnswer = async () => {
+  const projectDir = process.cwd();
+  const packageJsonPath = import_path7.default.join(projectDir, "package.json");
+  let framework = "tanstack state";
+  if (import_fs7.default.existsSync(packageJsonPath)) {
+    const packageJson2 = JSON.parse(import_fs7.default.readFileSync(packageJsonPath, "utf-8"));
+    const hasNext = packageJson2?.dependencies?.["next"] || packageJson2?.devDependencies?.["next"];
+    framework = hasNext ? "Next js" : "tanstack state";
+  }
+  console.log(`\u2714 Detected framework: ${framework}`);
   const answers = await import_inquirer.default.prompt([
     {
       type: "list",
@@ -457,48 +794,57 @@ var initAnswer = async () => {
       default: true
     }
   ]);
-  if (answers.orm === "Prisma") {
+  if (framework === "Next js" && answers.orm === "Prisma") {
     await prismaRun({
       authUi: answers.authUi,
       database: answers.database
     });
   }
-  if (answers.orm === "Drizzle") {
+  if (framework === "Next js" && answers.orm === "Drizzle") {
     await drizzleRun(answers.authUi);
   }
+  if (framework === "tanstack state" && answers.orm === "Prisma") {
+    await prismaRunTanstackState({
+      authUi: answers.authUi,
+      database: answers.database
+    });
+  }
+  if (framework === "tanstack state" && answers.orm === "Drizzle") {
+    await drizzleRunTanstackState(answers.authUi);
+  }
 };
 
 // index.ts
-var import_fs8 = require("fs");
+var import_fs17 = require("fs");
 
 // cli/provider.ts
-var import_chalk6 = __toESM(require("chalk"), 1);
+var import_chalk11 = __toESM(require("chalk"), 1);
 
 // script/googleRun.ts
-var import_chalk4 = __toESM(require("chalk"), 1);
-var import_fs4 = __toESM(require("fs"), 1);
-var import_path4 = __toESM(require("path"), 1);
-var import_url4 = require("url");
-var import_meta4 = {};
+var import_chalk7 = __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 googleRun = async () => {
   try {
-    const __filename = (0, import_url4.fileURLToPath)(import_meta4.url);
-    const __dirname = import_path4.default.dirname(__filename);
+    const __filename = (0, import_url7.fileURLToPath)(import_meta7.url);
+    const __dirname = import_path8.default.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = import_path4.default.join(projectDir, "src");
-    const folder = import_fs4.default.existsSync(srcPath) ? "src" : "";
-    const authFilePath = import_path4.default.join(projectDir, folder, "lib", "auth.ts");
-    if (!import_fs4.default.existsSync(authFilePath)) {
-      console.log(import_chalk4.default.red("\u274C auth.ts file not found"));
+    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_chalk7.default.red("\u274C auth.ts file not found"));
       return;
     }
-    let content = import_fs4.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs8.default.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(import_chalk4.default.red("betterAuth({}) block not found"));
+      console.log(import_chalk7.default.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("google:")) {
-      console.log(import_chalk4.default.yellow("Google provider already exists"));
+      console.log(import_chalk7.default.yellow("Google provider already exists"));
       return;
     }
     const googleProviderEntry = `
@@ -521,7 +867,7 @@ var googleRun = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(import_chalk4.default.red("Failed to parse socialProviders block"));
+        console.log(import_chalk7.default.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + googleProviderEntry + "\n  " + content.slice(insertPos);
@@ -529,7 +875,7 @@ var googleRun = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          import_chalk4.default.red(
+          import_chalk7.default.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -545,12 +891,12 @@ ${googleProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    import_fs4.default.writeFileSync(authFilePath, content, "utf8");
-    const envPath = import_path4.default.join(projectDir, ".env");
-    if (import_fs4.default.existsSync(envPath)) {
-      const envContent = import_fs4.default.readFileSync(envPath, "utf8");
+    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");
       if (!envContent.includes("GOOGLE_CLIENT_ID")) {
-        import_fs4.default.appendFileSync(
+        import_fs8.default.appendFileSync(
           envPath,
           `
 
@@ -561,54 +907,54 @@ GOOGLE_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = import_path4.default.resolve(
+    const componentTemplate = import_path8.default.resolve(
       __dirname,
       "./template/components/GoogleProviders.tsx"
     );
-    const componentsDir = import_path4.default.join(
+    const componentsDir = import_path8.default.join(
       projectDir,
       folder,
       "components",
       "authverse"
     );
-    if (!import_fs4.default.existsSync(componentsDir)) {
-      import_fs4.default.mkdirSync(componentsDir, { recursive: true });
+    if (!import_fs8.default.existsSync(componentsDir)) {
+      import_fs8.default.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = import_path4.default.join(componentsDir, "GoogleProviders.tsx");
-    if (import_fs4.default.existsSync(componentTemplate)) {
-      import_fs4.default.copyFileSync(componentTemplate, componentDest);
+    const componentDest = import_path8.default.join(componentsDir, "GoogleProviders.tsx");
+    if (import_fs8.default.existsSync(componentTemplate)) {
+      import_fs8.default.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(import_chalk4.default.green("Google provider added & merged successfully"));
+    console.log(import_chalk7.default.green("Google provider added & merged successfully"));
   } catch (error) {
-    console.log(import_chalk4.default.red("googleRun error:"), error);
+    console.log(import_chalk7.default.red("googleRun error:"), error);
   }
 };
 
 // script/githubRun.ts
-var import_chalk5 = __toESM(require("chalk"), 1);
-var import_fs5 = __toESM(require("fs"), 1);
-var import_path5 = __toESM(require("path"), 1);
-var import_url5 = require("url");
-var import_meta5 = {};
+var import_chalk8 = __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 githubRun = async () => {
   try {
-    const __filename = (0, import_url5.fileURLToPath)(import_meta5.url);
-    const __dirname = import_path5.default.dirname(__filename);
+    const __filename = (0, import_url8.fileURLToPath)(import_meta8.url);
+    const __dirname = import_path9.default.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = import_path5.default.join(projectDir, "src");
-    const folder = import_fs5.default.existsSync(srcPath) ? "src" : "";
-    const authFilePath = import_path5.default.join(projectDir, folder, "lib", "auth.ts");
-    if (!import_fs5.default.existsSync(authFilePath)) {
-      console.log(import_chalk5.default.red("auth.ts file not found"));
+    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_chalk8.default.red("auth.ts file not found"));
       return;
     }
-    let content = import_fs5.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs9.default.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(import_chalk5.default.red("betterAuth({}) block not found"));
+      console.log(import_chalk8.default.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("github:")) {
-      console.log(import_chalk5.default.yellow("GitHub provider already exists"));
+      console.log(import_chalk8.default.yellow("GitHub provider already exists"));
       return;
     }
     const githubProviderEntry = `
@@ -631,7 +977,7 @@ var githubRun = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(import_chalk5.default.red("Failed to parse socialProviders block"));
+        console.log(import_chalk8.default.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + githubProviderEntry + "\n  " + content.slice(insertPos);
@@ -639,7 +985,7 @@ var githubRun = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          import_chalk5.default.red(
+          import_chalk8.default.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -655,12 +1001,12 @@ ${githubProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    import_fs5.default.writeFileSync(authFilePath, content, "utf8");
-    const envPath = import_path5.default.join(projectDir, ".env");
-    if (import_fs5.default.existsSync(envPath)) {
-      const envContent = import_fs5.default.readFileSync(envPath, "utf8");
+    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");
       if (!envContent.includes("GITHUB_CLIENT_ID")) {
-        import_fs5.default.appendFileSync(
+        import_fs9.default.appendFileSync(
           envPath,
           `
 
@@ -671,71 +1017,300 @@ GITHUB_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = import_path5.default.resolve(
+    const componentTemplate = import_path9.default.resolve(
       __dirname,
       "./template/components/GithubProviders.tsx"
     );
-    const componentsDir = import_path5.default.join(
+    const componentsDir = import_path9.default.join(
       projectDir,
       folder,
       "components",
       "authverse"
     );
-    if (!import_fs5.default.existsSync(componentsDir)) {
-      import_fs5.default.mkdirSync(componentsDir, { recursive: true });
+    if (!import_fs9.default.existsSync(componentsDir)) {
+      import_fs9.default.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = import_path5.default.join(componentsDir, "GithubProviders.tsx");
-    if (import_fs5.default.existsSync(componentTemplate)) {
-      import_fs5.default.copyFileSync(componentTemplate, componentDest);
+    const componentDest = import_path9.default.join(componentsDir, "GithubProviders.tsx");
+    if (import_fs9.default.existsSync(componentTemplate)) {
+      import_fs9.default.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(import_chalk5.default.green("GitHub provider added & merged successfully"));
+    console.log(import_chalk8.default.green("GitHub provider added & merged successfully"));
   } catch (error) {
-    console.log(import_chalk5.default.red("githubRun error:"), error);
+    console.log(import_chalk8.default.red("githubRun error:"), error);
+  }
+};
+
+// cli/provider.ts
+var import_path12 = __toESM(require("path"), 1);
+var import_fs12 = __toESM(require("fs"), 1);
+
+// script/googleRunTanstackState.ts
+var import_chalk9 = __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 googleRunTanstackState = async () => {
+  try {
+    const __filename = (0, import_url9.fileURLToPath)(import_meta9.url);
+    const __dirname = import_path10.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_chalk9.default.red("auth.ts file not found"));
+      return;
+    }
+    let content = import_fs10.default.readFileSync(authFilePath, "utf8");
+    if (!content.includes("betterAuth({")) {
+      console.log(import_chalk9.default.red("betterAuth({}) block not found"));
+      return;
+    }
+    if (content.includes("socialProviders") && content.includes("google:")) {
+      console.log(import_chalk9.default.yellow("Google provider already exists"));
+      return;
+    }
+    const googleProviderEntry = `
+    google: {
+      clientId: process.env.GOOGLE_CLIENT_ID as string,
+      clientSecret: process.env.GOOGLE_CLIENT_SECRET as string,
+    },`;
+    if (content.includes("socialProviders: {")) {
+      const start = content.indexOf("socialProviders: {");
+      let braceCount = 0;
+      let insertPos = -1;
+      for (let i = start; i < content.length; i++) {
+        if (content[i] === "{") braceCount++;
+        if (content[i] === "}") {
+          braceCount--;
+          if (braceCount === 0) {
+            insertPos = i;
+            break;
+          }
+        }
+      }
+      if (insertPos === -1) {
+        console.log(import_chalk9.default.red("Failed to parse socialProviders block"));
+        return;
+      }
+      content = content.slice(0, insertPos) + googleProviderEntry + "\n  " + content.slice(insertPos);
+    } else {
+      const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
+      if (!databaseRegex.test(content)) {
+        console.log(
+          import_chalk9.default.red(
+            "Could not find database adapter (prismaAdapter or drizzleAdapter)"
+          )
+        );
+        return;
+      }
+      const socialProvidersBlock = `
+  socialProviders: {
+${googleProviderEntry}
+  },`;
+      content = content.replace(
+        databaseRegex,
+        (match) => `${match}
+${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");
+      if (!envContent.includes("GOOGLE_CLIENT_ID")) {
+        import_fs10.default.appendFileSync(
+          envPath,
+          `
+
+# Google OAuth
+GOOGLE_CLIENT_ID=
+GOOGLE_CLIENT_SECRET=
+`
+        );
+      }
+    }
+    const componentTemplate = import_path10.default.resolve(
+      __dirname,
+      "./template/TanstackState/components/GoogleProviders.tsx"
+    );
+    const componentsDir = import_path10.default.join(srcPath, "components", "authverse");
+    if (!import_fs10.default.existsSync(componentsDir)) {
+      import_fs10.default.mkdirSync(componentsDir, { recursive: true });
+    }
+    const componentDest = import_path10.default.join(componentsDir, "GoogleProviders.tsx");
+    if (import_fs10.default.existsSync(componentTemplate)) {
+      import_fs10.default.copyFileSync(componentTemplate, componentDest);
+    }
+    console.log(import_chalk9.default.green("Google provider added & merged successfully"));
+  } catch (error) {
+    console.log(import_chalk9.default.red("googleRunTanstackState error:"), error);
+  }
+};
+
+// script/githubRunTanstackState.ts
+var import_chalk10 = __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 githubRunTanstackState = async () => {
+  try {
+    const __filename = (0, import_url10.fileURLToPath)(import_meta10.url);
+    const __dirname = import_path11.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_chalk10.default.red("auth.ts file not found"));
+      return;
+    }
+    let content = import_fs11.default.readFileSync(authFilePath, "utf8");
+    if (!content.includes("betterAuth({")) {
+      console.log(import_chalk10.default.red("betterAuth({}) block not found"));
+      return;
+    }
+    if (content.includes("socialProviders") && content.includes("github:")) {
+      console.log(import_chalk10.default.yellow("Github provider already exists"));
+      return;
+    }
+    const githubProviderEntry = `
+    github: {
+      clientId: process.env.GITHUB_CLIENT_ID as string,
+      clientSecret: process.env.GITHUB_CLIENT_SECRET as string,
+    },`;
+    if (content.includes("socialProviders: {")) {
+      const start = content.indexOf("socialProviders: {");
+      let braceCount = 0;
+      let insertPos = -1;
+      for (let i = start; i < content.length; i++) {
+        if (content[i] === "{") braceCount++;
+        if (content[i] === "}") {
+          braceCount--;
+          if (braceCount === 0) {
+            insertPos = i;
+            break;
+          }
+        }
+      }
+      if (insertPos === -1) {
+        console.log(import_chalk10.default.red("Failed to parse socialProviders block"));
+        return;
+      }
+      content = content.slice(0, insertPos) + githubProviderEntry + "\n  " + content.slice(insertPos);
+    } else {
+      const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
+      if (!databaseRegex.test(content)) {
+        console.log(
+          import_chalk10.default.red(
+            "Could not find database adapter (prismaAdapter or drizzleAdapter)"
+          )
+        );
+        return;
+      }
+      const socialProvidersBlock = `
+  socialProviders: {
+${githubProviderEntry}
+  },`;
+      content = content.replace(
+        databaseRegex,
+        (match) => `${match}
+${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");
+      if (!envContent.includes("GITHUB_CLIENT_ID")) {
+        import_fs11.default.appendFileSync(
+          envPath,
+          `
+
+# Github OAuth
+GITHUB_CLIENT_ID=
+GITHUB_CLIENT_SECRET=
+`
+        );
+      }
+    }
+    const componentTemplate = import_path11.default.resolve(
+      __dirname,
+      "./template/TanstackState/components/GithubProviders.tsx"
+    );
+    const componentsDir = import_path11.default.join(srcPath, "components", "authverse");
+    if (!import_fs11.default.existsSync(componentsDir)) {
+      import_fs11.default.mkdirSync(componentsDir, { recursive: true });
+    }
+    const componentDest = import_path11.default.join(componentsDir, "GithubProviders.tsx");
+    if (import_fs11.default.existsSync(componentTemplate)) {
+      import_fs11.default.copyFileSync(componentTemplate, componentDest);
+    }
+    console.log(import_chalk10.default.green("Github provider added & merged successfully"));
+  } catch (error) {
+    console.log(import_chalk10.default.red("githubRunTanstackState error:"), error);
   }
 };
 
 // cli/provider.ts
 var providers = async ({ provider }) => {
   try {
-    if (provider == "google") {
+    const projectDir = process.cwd();
+    const packageJsonPath = import_path12.default.join(projectDir, "package.json");
+    let framework = "tanstack state";
+    if (import_fs12.default.existsSync(packageJsonPath)) {
+      const packageJson2 = JSON.parse(import_fs12.default.readFileSync(packageJsonPath, "utf-8"));
+      const hasNext = packageJson2?.dependencies?.["next"] || packageJson2?.devDependencies?.["next"];
+      framework = hasNext ? "Next js" : "tanstack state";
+    }
+    if (framework === "Next js" && provider == "google") {
       await googleRun();
-    } else if (provider == "github") {
+    } else if (framework === "Next js" && provider == "github") {
       await githubRun();
     }
+    if (framework === "tanstack state" && provider == "google") {
+      await googleRunTanstackState();
+    } else if (framework === "tanstack state" && provider == "github") {
+      await githubRunTanstackState();
+    }
   } catch (error) {
-    console.log(import_chalk6.default.red("Error adding provider:"), error);
+    console.log(import_chalk11.default.red("Error adding provider:"), error);
   }
 };
 
 // cli/forget.ts
-var import_chalk7 = __toESM(require("chalk"), 1);
-var import_path6 = __toESM(require("path"), 1);
-var import_url6 = require("url");
-var import_fs6 = __toESM(require("fs"), 1);
-var import_meta6 = {};
-var forget = async () => {
+var import_path15 = __toESM(require("path"), 1);
+var import_fs15 = __toESM(require("fs"), 1);
+
+// script/forgetNext.ts
+var import_chalk12 = __toESM(require("chalk"), 1);
+var import_path13 = __toESM(require("path"), 1);
+var import_url11 = require("url");
+var import_fs13 = __toESM(require("fs"), 1);
+var import_meta11 = {};
+var forgetNext = async () => {
   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_path13.default.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(import_fs13.default.readFileSync(packageJsonPath, "utf-8"));
     if (!packageJson2.dependencies?.resend) {
-      console.log(import_chalk7.default.cyan("\n\u2699\uFE0F Installing Resend...\n"));
+      console.log(import_chalk12.default.cyan("\n\u2699\uFE0F Installing Resend...\n"));
       packageManager("resend");
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(import_chalk7.default.cyan("\n\u2699\uFE0F Installing react email components...\n"));
+      console.log(import_chalk12.default.cyan("\n\u2699\uFE0F Installing react email components...\n"));
       packageManager("@react-email/components");
     }
-    const __filename = (0, import_url6.fileURLToPath)(import_meta6.url);
-    const __dirname = import_path6.default.dirname(__filename);
-    const srcPath = import_path6.default.join(projectDir, "src");
-    const folder = import_fs6.default.existsSync(srcPath) ? "src" : "";
-    const authFilePath = import_path6.default.join(projectDir, folder, "lib", "auth.ts");
-    if (!import_fs6.default.existsSync(authFilePath)) {
-      console.log(import_chalk7.default.red("auth.ts file not found."));
+    const __filename = (0, import_url11.fileURLToPath)(import_meta11.url);
+    const __dirname = import_path13.default.dirname(__filename);
+    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_chalk12.default.red("auth.ts file not found."));
       return;
     }
-    let content = import_fs6.default.readFileSync(authFilePath, "utf8");
+    let content = import_fs13.default.readFileSync(authFilePath, "utf8");
     const codeAdded = `sendResetPassword: async ({ user, url, token }) => {
       await resend.emails.send({
         from: \`\${process.env.EMAIL_SENDER_NAME} <\${process.env.EMAIL_SENDER_ADDRESS}>\`,
@@ -780,7 +1355,7 @@ var forget = async () => {
         content = before + `
  ${codeAdded}` + after;
       }
-      import_fs6.default.writeFileSync(authFilePath, content, "utf8");
+      import_fs13.default.writeFileSync(authFilePath, content, "utf8");
       if (!content.includes("import { Resend }") && !content.includes("const resend = new Resend")) {
         const lastImportIndex = content.lastIndexOf("import");
         const nextLineAfterLastImport = content.indexOf("\n", lastImportIndex) + 1;
@@ -792,126 +1367,325 @@ import ForgotPasswordEmail from "@/components/email/reset-password";
 const resend = new Resend(process.env.RESEND_API_KEY as string);
 `;
         content = beforeImports + newImports + afterImports;
-        import_fs6.default.writeFileSync(authFilePath, content, "utf8");
+        import_fs13.default.writeFileSync(authFilePath, content, "utf8");
       }
-      const envPath = import_path6.default.join(projectDir, ".env");
-      const envContent = import_fs6.default.readFileSync(envPath, "utf8");
+      const envPath = import_path13.default.join(projectDir, ".env");
+      const envContent = import_fs13.default.readFileSync(envPath, "utf8");
       if (!envContent.includes("RESEND_API_KEY") && !envContent.includes("EMAIL_SENDER_NAME") && !envContent.includes("EMAIL_SENDER_ADDRESS")) {
-        import_fs6.default.appendFileSync(envPath, `
+        import_fs13.default.appendFileSync(envPath, `
 
 # Resend API Key for sending emails`);
-        import_fs6.default.appendFileSync(envPath, `
+        import_fs13.default.appendFileSync(envPath, `
 RESEND_API_KEY=`);
-        import_fs6.default.appendFileSync(envPath, `
+        import_fs13.default.appendFileSync(envPath, `
 EMAIL_SENDER_NAME=Your Name`);
-        import_fs6.default.appendFileSync(envPath, `
+        import_fs13.default.appendFileSync(envPath, `
 EMAIL_SENDER_ADDRESS=`);
       }
-      const componentPath = import_path6.default.resolve(
+      const componentPath = import_path13.default.resolve(
         __dirname,
         "./template/email/reset-password.tsx"
       );
-      const destinationPath = import_path6.default.join(
+      const destinationPath = import_path13.default.join(
         projectDir,
         folder,
         "components",
         "email"
       );
-      if (!import_fs6.default.existsSync(destinationPath)) {
-        import_fs6.default.mkdirSync(destinationPath, { recursive: true });
+      if (!import_fs13.default.existsSync(destinationPath)) {
+        import_fs13.default.mkdirSync(destinationPath, { recursive: true });
       }
-      const emailDestinationPath = import_path6.default.join(
+      const emailDestinationPath = import_path13.default.join(
         destinationPath,
         "reset-password.tsx"
       );
-      if (import_fs6.default.existsSync(componentPath)) {
-        import_fs6.default.copyFileSync(componentPath, emailDestinationPath);
+      if (import_fs13.default.existsSync(componentPath)) {
+        import_fs13.default.copyFileSync(componentPath, emailDestinationPath);
       }
-      const forgetComponentPath = import_path6.default.resolve(
+      const forgetComponentPath = import_path13.default.resolve(
         __dirname,
         "./template/components/ForgetComponent.tsx"
       );
-      const componentsDestinationPath = import_path6.default.join(
+      const componentsDestinationPath = import_path13.default.join(
         projectDir,
         folder,
         "components",
         "authverse"
       );
-      if (!import_fs6.default.existsSync(componentsDestinationPath)) {
-        import_fs6.default.mkdirSync(componentsDestinationPath, { recursive: true });
+      if (!import_fs13.default.existsSync(componentsDestinationPath)) {
+        import_fs13.default.mkdirSync(componentsDestinationPath, { recursive: true });
       }
-      const forgetDestinationPath = import_path6.default.join(
+      const forgetDestinationPath = import_path13.default.join(
         componentsDestinationPath,
         "ForgetComponent.tsx"
       );
-      if (import_fs6.default.existsSync(forgetComponentPath)) {
-        import_fs6.default.copyFileSync(forgetComponentPath, forgetDestinationPath);
+      if (import_fs13.default.existsSync(forgetComponentPath)) {
+        import_fs13.default.copyFileSync(forgetComponentPath, forgetDestinationPath);
       }
-      const resetComponentPath = import_path6.default.resolve(
+      const resetComponentPath = import_path13.default.resolve(
         __dirname,
         "./template/components/ResetComponent.tsx"
       );
-      const resetDestinationPath = import_path6.default.join(
+      const resetDestinationPath = import_path13.default.join(
         componentsDestinationPath,
         "ResetComponent.tsx"
       );
-      if (import_fs6.default.existsSync(resetComponentPath)) {
-        import_fs6.default.copyFileSync(resetComponentPath, resetDestinationPath);
+      if (import_fs13.default.existsSync(resetComponentPath)) {
+        import_fs13.default.copyFileSync(resetComponentPath, resetDestinationPath);
       }
-      const authTemplatePath = import_path6.default.resolve(
+      const authTemplatePath = import_path13.default.resolve(
         __dirname,
         "./template/app-auth-uiDesign"
       );
-      const appDestinationPath = import_path6.default.join(projectDir, folder, "app", "auth");
-      if (!import_fs6.default.existsSync(appDestinationPath)) {
-        import_fs6.default.mkdirSync(appDestinationPath, { recursive: true });
+      const appDestinationPath = import_path13.default.join(projectDir, folder, "app", "auth");
+      if (!import_fs13.default.existsSync(appDestinationPath)) {
+        import_fs13.default.mkdirSync(appDestinationPath, { recursive: true });
       }
-      const forgetDestinationDir = import_path6.default.join(appDestinationPath, "forget");
-      if (!import_fs6.default.existsSync(forgetDestinationDir)) {
-        import_fs6.default.mkdirSync(forgetDestinationDir, { recursive: true });
+      const forgetDestinationDir = import_path13.default.join(appDestinationPath, "forget");
+      if (!import_fs13.default.existsSync(forgetDestinationDir)) {
+        import_fs13.default.mkdirSync(forgetDestinationDir, { recursive: true });
       }
-      const forgetPageDestinationPath = import_path6.default.join(
+      const forgetPageDestinationPath = import_path13.default.join(
         forgetDestinationDir,
         "page.tsx"
       );
-      import_fs6.default.copyFileSync(
+      import_fs13.default.copyFileSync(
         `${authTemplatePath}/forget/page.tsx`,
         forgetPageDestinationPath
       );
-      const resetDestinationDir = import_path6.default.join(
+      const resetDestinationDir = import_path13.default.join(
         appDestinationPath,
         "reset-password"
       );
-      if (!import_fs6.default.existsSync(resetDestinationDir)) {
-        import_fs6.default.mkdirSync(resetDestinationDir, { recursive: true });
+      if (!import_fs13.default.existsSync(resetDestinationDir)) {
+        import_fs13.default.mkdirSync(resetDestinationDir, { recursive: true });
       }
-      const resetPageDestinationPath = import_path6.default.join(
+      const resetPageDestinationPath = import_path13.default.join(
         resetDestinationDir,
         "page.tsx"
       );
-      import_fs6.default.copyFileSync(
+      import_fs13.default.copyFileSync(
         `${authTemplatePath}/reset-password/page.tsx`,
         resetPageDestinationPath
       );
       console.log(
-        import_chalk7.default.green("Successfully added forget and reset-password pages")
+        import_chalk12.default.green("Successfully added forget and reset-password pages")
       );
     } else {
       console.log(
-        import_chalk7.default.red("Could not find emailAndPassword configuration in auth.ts")
+        import_chalk12.default.red("Could not find emailAndPassword configuration in auth.ts")
       );
     }
   } catch (error) {
-    console.log(import_chalk7.default.red("Error adding sendResetPassword:"), error);
+    console.log(import_chalk12.default.red("Error adding sendResetPassword:"), error);
+  }
+};
+
+// script/forgetTanstack.ts
+var import_chalk13 = __toESM(require("chalk"), 1);
+var import_path14 = __toESM(require("path"), 1);
+var import_url12 = require("url");
+var import_fs14 = __toESM(require("fs"), 1);
+var import_meta12 = {};
+var forgetTanstack = async () => {
+  try {
+    const projectDir = process.cwd();
+    const packageJsonPath = import_path14.default.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(import_fs14.default.readFileSync(packageJsonPath, "utf-8"));
+    if (!packageJson2.dependencies?.resend) {
+      console.log(import_chalk13.default.cyan("\n\u2699\uFE0F Installing Resend...\n"));
+      packageManager("resend");
+    }
+    if (!packageJson2.dependencies?.["@react-email/components"]) {
+      console.log(import_chalk13.default.cyan("\n\u2699\uFE0F Installing react email components...\n"));
+      packageManager("@react-email/components");
+    }
+    const __filename = (0, import_url12.fileURLToPath)(import_meta12.url);
+    const __dirname = import_path14.default.dirname(__filename);
+    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_chalk13.default.red("auth.ts file not found."));
+      return;
+    }
+    let content = import_fs14.default.readFileSync(authFilePath, "utf8");
+    const codeAdded = `sendResetPassword: async ({ user, url, token }) => {
+      await resend.emails.send({
+        from: \`\${process.env.EMAIL_SENDER_NAME} <\${process.env.EMAIL_SENDER_ADDRESS}>\`,
+        to: user.email,
+        subject: "Reset your password",
+        react: ForgotPasswordEmail({
+          username: user.name,
+          resetUrl: url,
+          userEmail: user.email,
+        }),
+      });
+    },`;
+    if (content.includes("emailAndPassword: {")) {
+      const emailAndPasswordStart = content.indexOf("emailAndPassword: {");
+      let emailAndPasswordEnd = emailAndPasswordStart;
+      let braceCount = 0;
+      let inEmailAndPassword = false;
+      for (let i = emailAndPasswordStart; i < content.length; i++) {
+        if (content[i] === "{") {
+          braceCount++;
+          inEmailAndPassword = true;
+        } else if (content[i] === "}") {
+          braceCount--;
+          if (inEmailAndPassword && braceCount === 0) {
+            emailAndPasswordEnd = i;
+            break;
+          }
+        }
+      }
+      const emailAndPasswordContent = content.substring(
+        emailAndPasswordStart,
+        emailAndPasswordEnd
+      );
+      if (emailAndPasswordContent.includes("sendResetPassword:")) {
+        content = content.replace(
+          /sendResetPassword:\s*async\s*\([^)]*\)[^{]*\{[^}]*\}[^,]*/,
+          codeAdded
+        );
+      } else {
+        const before = content.substring(0, emailAndPasswordEnd);
+        const after = content.substring(emailAndPasswordEnd);
+        content = before + `
+ ${codeAdded}` + after;
+      }
+      import_fs14.default.writeFileSync(authFilePath, content, "utf8");
+      if (!content.includes("import { Resend }") && !content.includes("const resend = new Resend")) {
+        const lastImportIndex = content.lastIndexOf("import");
+        const nextLineAfterLastImport = content.indexOf("\n", lastImportIndex) + 1;
+        const beforeImports = content.substring(0, nextLineAfterLastImport);
+        const afterImports = content.substring(nextLineAfterLastImport);
+        const newImports = `import { Resend } from "resend";
+import ForgotPasswordEmail from "@/components/email/reset-password";
+
+const resend = new Resend(process.env.RESEND_API_KEY as string);
+`;
+        content = beforeImports + newImports + afterImports;
+        import_fs14.default.writeFileSync(authFilePath, content, "utf8");
+      }
+      const envPath = import_path14.default.join(projectDir, ".env");
+      const envContent = import_fs14.default.readFileSync(envPath, "utf8");
+      if (!envContent.includes("RESEND_API_KEY") && !envContent.includes("EMAIL_SENDER_NAME") && !envContent.includes("EMAIL_SENDER_ADDRESS")) {
+        import_fs14.default.appendFileSync(envPath, `
+
+# Resend API Key for sending emails`);
+        import_fs14.default.appendFileSync(envPath, `
+RESEND_API_KEY=`);
+        import_fs14.default.appendFileSync(envPath, `
+EMAIL_SENDER_NAME=Your Name`);
+        import_fs14.default.appendFileSync(envPath, `
+EMAIL_SENDER_ADDRESS=`);
+      }
+      const componentPath = import_path14.default.resolve(
+        __dirname,
+        "./template/email/reset-password.tsx"
+      );
+      const destinationPath = import_path14.default.join(srcPath, "components", "email");
+      if (!import_fs14.default.existsSync(destinationPath)) {
+        import_fs14.default.mkdirSync(destinationPath, { recursive: true });
+      }
+      const emailDestinationPath = import_path14.default.join(
+        destinationPath,
+        "reset-password.tsx"
+      );
+      if (import_fs14.default.existsSync(componentPath)) {
+        import_fs14.default.copyFileSync(componentPath, emailDestinationPath);
+      }
+      const forgetComponentPath = import_path14.default.resolve(
+        __dirname,
+        "./template/TanstackState/components/ForgetComponent.tsx"
+      );
+      const componentsDestinationPath = import_path14.default.join(
+        srcPath,
+        "components",
+        "authverse"
+      );
+      if (!import_fs14.default.existsSync(componentsDestinationPath)) {
+        import_fs14.default.mkdirSync(componentsDestinationPath, { recursive: true });
+      }
+      const forgetDestinationPath = import_path14.default.join(
+        componentsDestinationPath,
+        "ForgetComponent.tsx"
+      );
+      if (import_fs14.default.existsSync(forgetComponentPath)) {
+        import_fs14.default.copyFileSync(forgetComponentPath, forgetDestinationPath);
+      }
+      const resetComponentPath = import_path14.default.resolve(
+        __dirname,
+        "./template/TanstackState/components/ResetComponent.tsx"
+      );
+      const resetDestinationPath = import_path14.default.join(
+        componentsDestinationPath,
+        "ResetComponent.tsx"
+      );
+      if (import_fs14.default.existsSync(resetComponentPath)) {
+        import_fs14.default.copyFileSync(resetComponentPath, resetDestinationPath);
+      }
+      const authTemplatePath = import_path14.default.resolve(
+        __dirname,
+        "./template/TanstackState/routes/auth"
+      );
+      const routesDestinationPath = import_path14.default.join(srcPath, "routes", "auth");
+      if (!import_fs14.default.existsSync(routesDestinationPath)) {
+        import_fs14.default.mkdirSync(routesDestinationPath, { recursive: true });
+      }
+      const forgetPageDestinationPath = import_path14.default.join(
+        routesDestinationPath,
+        "forget.tsx"
+      );
+      import_fs14.default.copyFileSync(
+        `${authTemplatePath}/forget.tsx`,
+        forgetPageDestinationPath
+      );
+      const resetPageDestinationPath = import_path14.default.join(
+        routesDestinationPath,
+        "reset-password.tsx"
+      );
+      import_fs14.default.copyFileSync(
+        `${authTemplatePath}/reset-password.tsx`,
+        resetPageDestinationPath
+      );
+      console.log(
+        import_chalk13.default.green("Successfully added forget and reset-password pages")
+      );
+    } else {
+      console.log(
+        import_chalk13.default.red("Could not find emailAndPassword configuration in auth.ts")
+      );
+    }
+  } catch (error) {
+    console.log(import_chalk13.default.red("Error adding sendResetPassword:"), error);
+  }
+};
+
+// cli/forget.ts
+var forget = () => {
+  const projectDir = process.cwd();
+  const packageJsonPath = import_path15.default.join(projectDir, "package.json");
+  let framework = "tanstack state";
+  if (import_fs15.default.existsSync(packageJsonPath)) {
+    const packageJson2 = JSON.parse(import_fs15.default.readFileSync(packageJsonPath, "utf-8"));
+    const hasNext = packageJson2?.dependencies?.["next"] || packageJson2?.devDependencies?.["next"];
+    framework = hasNext ? "Next js" : "tanstack state";
+  }
+  if (framework === "Next js") {
+    return forgetNext();
+  }
+  if (framework === "tanstack state") {
+    return forgetTanstack();
   }
 };
 
 // script/detect-nextjs.ts
-var import_fs7 = require("fs");
+var import_fs16 = require("fs");
 function isNextJsProject() {
-  if (!(0, import_fs7.existsSync)("./package.json")) return false;
+  if (!(0, import_fs16.existsSync)("./package.json")) return false;
   try {
-    const pkg = JSON.parse((0, import_fs7.readFileSync)("./package.json", "utf8"));
+    const pkg = JSON.parse((0, import_fs16.readFileSync)("./package.json", "utf8"));
     const deps = {
       ...pkg.dependencies,
       ...pkg.devDependencies
@@ -923,8 +1697,8 @@ function isNextJsProject() {
 }
 
 // index.ts
-var import_chalk8 = __toESM(require("chalk"), 1);
-var packageJson = JSON.parse((0, import_fs8.readFileSync)("./package.json", "utf8"));
+var import_chalk14 = __toESM(require("chalk"), 1);
+var packageJson = JSON.parse((0, import_fs17.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",
@@ -933,7 +1707,7 @@ program.name("authverse").description("CLI tool for creating authverse projects"
 );
 program.command("init").description("Select project template and configuration").action(() => {
   if (!isNextJsProject) {
-    console.log(import_chalk8.default.red("Only Next.js projects are supported."));
+    console.log(import_chalk14.default.red("Only Next.js projects are supported."));
     process.exit(1);
   }
   initAnswer();