authverse 1.0.4

package/dist/index.js

@@ -0,0 +1,799 @@
+#!/usr/bin/env node
+
+// index.ts
+import { Command } from "commander";
+
+// cli/init.ts
+import inquirer from "inquirer";
+
+// script/prisma.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+import path2 from "path";
+import fs2 from "fs";
+import chalk2 from "chalk";
+import { execSync as execSync2 } from "child_process";
+
+// function/GenerateSecret.ts
+import crypto from "crypto";
+var GenerateSecret = async () => {
+  const secret = crypto.randomBytes(64).toString("hex");
+  return secret;
+};
+
+// script/authUi.ts
+import chalk from "chalk";
+import { execSync } from "child_process";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+var authUiRun = async ({ folder }) => {
+  try {
+    console.log(chalk.yellow("\n Updating AuthUi Files\n"));
+    execSync("npx shadcn@latest add button sonner card field input", {
+      stdio: "inherit"
+    });
+    execSync("npm install react-hook-form @hookform/resolvers", {
+      stdio: "inherit"
+    });
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const projectDir = process.cwd();
+    const componentPath = path.resolve(__dirname, "./template/components");
+    const destinationPath = path.join(
+      projectDir,
+      folder,
+      "components",
+      "authverse"
+    );
+    if (!fs.existsSync(destinationPath)) {
+      fs.mkdirSync(destinationPath, { recursive: true });
+    }
+    const LoginDestinationPath = path.join(
+      destinationPath,
+      "LoginComponent.tsx"
+    );
+    fs.copyFileSync(
+      `${componentPath}/LoginComponent.tsx`,
+      LoginDestinationPath
+    );
+    const SignUpDestinationPath = path.join(
+      destinationPath,
+      "SingUpComponent.tsx"
+    );
+    fs.copyFileSync(
+      `${componentPath}/SingUpComponent.tsx`,
+      SignUpDestinationPath
+    );
+    const LogoutDestinationPath = path.join(destinationPath, "Logout.tsx");
+    fs.copyFileSync(`${componentPath}/Logout.tsx`, LogoutDestinationPath);
+    const authTemplatePath = path.resolve(
+      __dirname,
+      "./template/app-auth-uiDesign"
+    );
+    const appDestinationPath = path.join(projectDir, folder, "app", "auth");
+    if (!fs.existsSync(appDestinationPath)) {
+      fs.mkdirSync(appDestinationPath, { recursive: true });
+    }
+    const layoutDestinationPath = path.join(appDestinationPath, "layout.tsx");
+    fs.copyFileSync(`${authTemplatePath}/layout.tsx`, layoutDestinationPath);
+    const loginDestinationDir = path.join(appDestinationPath, "login");
+    if (!fs.existsSync(loginDestinationDir)) {
+      fs.mkdirSync(loginDestinationDir, { recursive: true });
+    }
+    const loginPageDestinationPath = path.join(loginDestinationDir, "page.tsx");
+    fs.copyFileSync(
+      `${authTemplatePath}/login/page.tsx`,
+      loginPageDestinationPath
+    );
+    const signUpDestinationDir = path.join(appDestinationPath, "signup");
+    if (!fs.existsSync(signUpDestinationDir)) {
+      fs.mkdirSync(signUpDestinationDir, { recursive: true });
+    }
+    const signUpPageDestinationPath = path.join(
+      signUpDestinationDir,
+      "page.tsx"
+    );
+    fs.copyFileSync(
+      `${authTemplatePath}/signup/page.tsx`,
+      signUpPageDestinationPath
+    );
+    const layoutPath = path.join(projectDir, folder, "app", "layout.tsx");
+    if (fs.existsSync(layoutPath)) {
+      let layoutContent = fs.readFileSync(layoutPath, "utf-8");
+      if (!layoutContent.includes("Toaster")) {
+        layoutContent = `import { Toaster } from "@/components/ui/sonner";
+${layoutContent}`;
+      }
+      if (!layoutContent.includes("<Toaster")) {
+        layoutContent = layoutContent.replace(
+          /<\/body>/,
+          "    <Toaster />\n  </body>"
+        );
+      }
+      fs.writeFileSync(layoutPath, layoutContent, "utf-8");
+    }
+    console.log(chalk.green("\nSetup completed!\n"));
+  } catch (error) {
+    console.log(chalk.red("\nauthUi setup failed:"), error);
+  }
+};
+
+// script/prisma.ts
+var prismaRun = async ({ authUi, database }) => {
+  try {
+    console.log(chalk2.cyan("\n\u2699\uFE0F  Initializing Prisma...\n"));
+    if (database !== "Mongodb") {
+      execSync2("npm install prisma --save-dev", { stdio: "inherit" });
+      execSync2("npm install @prisma/client", { stdio: "inherit" });
+      if (database === "Mysql") {
+        execSync2("npm install @prisma/adapter-mariadb", { stdio: "inherit" });
+      }
+      if (database === "Postgresql") {
+        execSync2("npm install @prisma/adapter-pg", { stdio: "inherit" });
+      }
+    } else if (database === "Mongodb") {
+      execSync2("npm install prisma@6.19.0 --save-dev", { stdio: "inherit" });
+      execSync2("npm install @prisma/client@6.19.0", { stdio: "inherit" });
+    }
+    const projectDir = process.cwd();
+    const prismaDir = path2.join(projectDir, "prisma");
+    if (!fs2.existsSync(prismaDir)) {
+      console.log(chalk2.yellow("\n\u2699\uFE0F  Initializing Prisma...\n"));
+      execSync2("npx prisma init", { stdio: "inherit" });
+    }
+    const __filename = fileURLToPath2(import.meta.url);
+    const __dirname = path2.dirname(__filename);
+    const templatePath = path2.resolve(
+      __dirname,
+      `./template/prisma/${database}/schema.prisma`
+    );
+    if (!fs2.existsSync(prismaDir)) {
+      fs2.mkdirSync(prismaDir, { recursive: true });
+    }
+    const destinationPath = path2.join(prismaDir, "schema.prisma");
+    fs2.copyFileSync(templatePath, destinationPath);
+    if (database === "Mongodb") {
+      const prismaConfigPath = path2.resolve(
+        __dirname,
+        `./template/config/prisma.config.ts`
+      );
+      const prismaConfigDestinationPath = path2.join("", "prisma.config.ts");
+      fs2.copyFileSync(prismaConfigPath, prismaConfigDestinationPath);
+    }
+    console.log(chalk2.yellow("\n\u2699\uFE0F  Initializing better-auth...\n"));
+    execSync2("npm install better-auth", { stdio: "inherit" });
+    const secret = await GenerateSecret();
+    const envPath = path2.join(projectDir, ".env");
+    fs2.appendFileSync(envPath, `
+
+BETTER_AUTH_SECRET=${secret}`);
+    fs2.appendFileSync(envPath, `
+BETTER_AUTH_URL=http://localhost:3000
+`);
+    console.log(chalk2.yellow("\n create folder...\n"));
+    const srcPath = path2.join(projectDir, "src");
+    const folder = srcPath ? "" : "src";
+    const libPath = path2.join(projectDir, folder, "lib");
+    if (!fs2.existsSync(libPath)) {
+      fs2.mkdirSync(libPath, { recursive: true });
+    }
+    const authTemplatePath = path2.resolve(
+      __dirname,
+      `./template/lib/${database}/auth.ts`
+    );
+    const authDestinationPath = path2.join(libPath, "auth.ts");
+    fs2.copyFileSync(authTemplatePath, authDestinationPath);
+    const authClientTemplatePath = path2.resolve(
+      __dirname,
+      "./template/lib/auth-client.ts"
+    );
+    const authClientDestinationPath = path2.join(libPath, "auth-client.ts");
+    fs2.copyFileSync(authClientTemplatePath, authClientDestinationPath);
+    const serverPath = path2.join(projectDir, folder, "server");
+    if (!fs2.existsSync(serverPath)) {
+      fs2.mkdirSync(serverPath, { recursive: true });
+    }
+    const userTemplatePath = path2.resolve(
+      __dirname,
+      "./template/server/user.ts"
+    );
+    const userDestinationPath = path2.join(serverPath, "user.ts");
+    fs2.copyFileSync(userTemplatePath, userDestinationPath);
+    const routeTemplatePath = path2.resolve(
+      __dirname,
+      "./template/api/route.ts"
+    );
+    const routeDestinationDir = path2.join(
+      projectDir,
+      "app",
+      "api",
+      "auth",
+      "[...all]"
+    );
+    if (!fs2.existsSync(routeDestinationDir)) {
+      fs2.mkdirSync(routeDestinationDir, { recursive: true });
+    }
+    const routeDestinationPath = path2.join(routeDestinationDir, "route.ts");
+    fs2.copyFileSync(routeTemplatePath, routeDestinationPath);
+    const proxyTemplatePath = path2.resolve(
+      __dirname,
+      "./template/proxy/proxy.ts"
+    );
+    const proxyDestinationDir = path2.join(projectDir, folder);
+    const proxyDestinationPath = path2.join(proxyDestinationDir, "proxy.ts");
+    fs2.copyFileSync(proxyTemplatePath, proxyDestinationPath);
+    if (authUi) {
+      await authUiRun({ folder });
+    } else {
+      console.log(
+        chalk2.green(
+          "\nPrisma setup completed successfully and better-auth installed\n"
+        )
+      );
+    }
+  } catch (err) {
+    console.error(chalk2.red("Prisma setup failed:"), err);
+  }
+};
+
+// script/drizzleRun.ts
+import chalk3 from "chalk";
+import { execSync as execSync3 } from "child_process";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import fs3 from "fs";
+var drizzleRun = async (authUi) => {
+  try {
+    console.log(chalk3.cyan("\n\u2699\uFE0F  Initializing better auth and drizzle...\n"));
+    execSync3("npm install better-auth", { stdio: "inherit" });
+    execSync3("npm install drizzle-orm @neondatabase/serverless dotenv", {
+      stdio: "inherit"
+    });
+    execSync3("npm install -D drizzle-kit", { stdio: "inherit" });
+    const __filename = fileURLToPath3(import.meta.url);
+    const __dirname = path3.dirname(__filename);
+    const projectDir = process.cwd();
+    const envPath = path3.join(projectDir, ".env");
+    if (!fs3.existsSync(envPath)) {
+      fs3.writeFileSync(envPath, "DATABASE_URL=\n");
+    }
+    const secret = await GenerateSecret();
+    fs3.appendFileSync(envPath, `
+
+BETTER_AUTH_SECRET=${secret}`);
+    fs3.appendFileSync(envPath, `
+BETTER_AUTH_URL=http://localhost:3000
+`);
+    const srcPath = path3.join(projectDir, "src");
+    const folder = srcPath ? "" : "src";
+    const libPath = path3.join(projectDir, folder, "lib");
+    if (!fs3.existsSync(libPath)) {
+      fs3.mkdirSync(libPath, { recursive: true });
+    }
+    const authTemplatePath = path3.resolve(
+      __dirname,
+      "./template/lib/auth-drizzle.ts"
+    );
+    const authDestinationPath = path3.join(libPath, "auth.ts");
+    fs3.copyFileSync(authTemplatePath, authDestinationPath);
+    const authClientTemplatePath = path3.resolve(
+      __dirname,
+      "./template/lib/auth-client.ts"
+    );
+    const authClientDestinationPath = path3.join(libPath, "auth-client.ts");
+    fs3.copyFileSync(authClientTemplatePath, authClientDestinationPath);
+    const dbTemplatePath = path3.resolve(__dirname, "./template/db");
+    const dbDir = path3.join(projectDir, folder, "db");
+    if (!fs3.existsSync(dbDir)) {
+      fs3.mkdirSync(dbDir, { recursive: true });
+    }
+    const dbDestinationPath = path3.join(dbDir, "drizzle.ts");
+    fs3.copyFileSync(`${dbTemplatePath}/drizzle.ts`, dbDestinationPath);
+    const schemaDestinationPath = path3.join(dbDir, "schema.ts");
+    fs3.copyFileSync(`${dbTemplatePath}/schema.ts`, schemaDestinationPath);
+    const drizzleConfigTemplatePath = path3.resolve(
+      __dirname,
+      "./template/config/drizzle.config.ts"
+    );
+    const drizzleConfigDestinationPath = path3.join(
+      projectDir,
+      "drizzle.config.ts"
+    );
+    fs3.copyFileSync(drizzleConfigTemplatePath, drizzleConfigDestinationPath);
+    const serverPath = path3.join(projectDir, folder, "server");
+    if (!fs3.existsSync(serverPath)) {
+      fs3.mkdirSync(serverPath, { recursive: true });
+    }
+    const userTemplatePath = path3.resolve(
+      __dirname,
+      "./template/server/user.ts"
+    );
+    const userDestinationPath = path3.join(serverPath, "user.ts");
+    fs3.copyFileSync(userTemplatePath, userDestinationPath);
+    const routeTemplatePath = path3.resolve(
+      __dirname,
+      "./template/api/route.ts"
+    );
+    const routeDestinationDir = path3.join(
+      projectDir,
+      "app",
+      "api",
+      "auth",
+      "[...all]"
+    );
+    if (!fs3.existsSync(routeDestinationDir)) {
+      fs3.mkdirSync(routeDestinationDir, { recursive: true });
+    }
+    const routeDestinationPath = path3.join(routeDestinationDir, "route.ts");
+    fs3.copyFileSync(routeTemplatePath, routeDestinationPath);
+    const proxyTemplatePath = path3.resolve(
+      __dirname,
+      "./template/proxy/proxy.ts"
+    );
+    const proxyDestinationDir = path3.join(projectDir, folder);
+    const proxyDestinationPath = path3.join(proxyDestinationDir, "proxy.ts");
+    fs3.copyFileSync(proxyTemplatePath, proxyDestinationPath);
+    if (authUi) {
+      await authUiRun({ folder });
+    } else {
+      console.log(
+        chalk3.green(
+          "\nDrizzle setup completed successfully and better-auth installed\n"
+        )
+      );
+    }
+  } catch (err) {
+    console.error(chalk3.red("Drizzle setup failed:"), err);
+  }
+};
+
+// cli/init.ts
+var initAnswer = async () => {
+  const answers = await inquirer.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
+    }
+  ]);
+  if (answers.orm === "Prisma") {
+    await prismaRun({
+      authUi: answers.authUi,
+      database: answers.database
+    });
+  }
+  if (answers.orm === "Drizzle") {
+    await drizzleRun(answers.authUi);
+  }
+};
+
+// index.ts
+import { readFileSync as readFileSync2 } from "fs";
+
+// cli/provider.ts
+import chalk6 from "chalk";
+
+// script/googleRun.ts
+import chalk4 from "chalk";
+import { execSync as execSync4 } from "child_process";
+import fs4 from "fs";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+var googleRun = async () => {
+  try {
+    execSync4("npm install react-icons --save", { stdio: "inherit" });
+    const __filename = fileURLToPath4(import.meta.url);
+    const __dirname = path4.dirname(__filename);
+    const projectDir = process.cwd();
+    const srcPath = path4.join(projectDir, "src");
+    const folder = srcPath ? "" : "src";
+    const authFilePath = path4.join(projectDir, folder, "lib", "auth.ts");
+    if (!fs4.existsSync(authFilePath)) {
+      console.log(chalk4.red("auth.ts file not found."));
+      return;
+    }
+    let content = fs4.readFileSync(authFilePath, "utf8");
+    const socialProvidersCode = `
+  socialProviders: {
+    google: {
+      clientId: process.env.GOOGLE_CLIENT_ID as string,
+      clientSecret: process.env.GOOGLE_CLIENT_SECRET as string,
+    },
+  }`;
+    if (content.includes("betterAuth({")) {
+      content = content.replace(/betterAuth\(\{([\s\S]*?)\}\)/, (inner) => {
+        return `
+${inner.trimEnd()},${socialProvidersCode}`;
+      });
+      fs4.writeFileSync(authFilePath, content, "utf8");
+      const envPath = path4.join(projectDir, ".env");
+      fs4.appendFileSync(envPath, `
+
+# Google OAuth Credentials`);
+      fs4.appendFileSync(envPath, `
+GOOGLE_CLIENT_ID=`);
+      fs4.appendFileSync(envPath, `
+GOOGLE_CLIENT_SECRET=`);
+      const componentPath = path4.resolve(
+        __dirname,
+        "./template/components/GoogleProviders.tsx"
+      );
+      const destinationPath = path4.join(
+        projectDir,
+        folder,
+        "components",
+        "authverse"
+      );
+      if (!fs4.existsSync(destinationPath)) {
+        fs4.mkdirSync(destinationPath, { recursive: true });
+      }
+      const LoginDestinationPath = path4.join(
+        destinationPath,
+        "GoogleProviders.tsx"
+      );
+      fs4.copyFileSync(componentPath, LoginDestinationPath);
+      console.log(
+        chalk4.green("Added socialProviders with Google provider successfully")
+      );
+    } else {
+      console.log(chalk4.red("Could not find betterAuth({ }) block in auth.ts"));
+    }
+  } catch (error) {
+    console.log(chalk4.red("Error adding socialProviders:"), error);
+  }
+};
+
+// script/githubRun.ts
+import chalk5 from "chalk";
+import { execSync as execSync5 } from "child_process";
+import fs5 from "fs";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+var githubRun = async () => {
+  try {
+    execSync5("npm install react-icons --save", { stdio: "inherit" });
+    const __filename = fileURLToPath5(import.meta.url);
+    const __dirname = path5.dirname(__filename);
+    const projectDir = process.cwd();
+    const srcPath = path5.join(projectDir, "src");
+    const folder = fs5.existsSync(srcPath) ? "src" : "";
+    const authFilePath = path5.join(projectDir, folder, "lib", "auth.ts");
+    if (!fs5.existsSync(authFilePath)) {
+      console.log(chalk5.red("auth.ts file not found."));
+      return;
+    }
+    let content = fs5.readFileSync(authFilePath, "utf8");
+    const githubProviderCode = `github: {
+      clientId: process.env.GITHUB_CLIENT_ID as string,
+      clientSecret: process.env.GITHUB_CLIENT_SECRET as string,
+    },`;
+    if (content.includes("betterAuth({")) {
+      if (content.includes("socialProviders:")) {
+        const socialProvidersStart = content.indexOf("socialProviders: {");
+        let socialProvidersEnd = socialProvidersStart;
+        let braceCount = 0;
+        let inSocialProviders = false;
+        for (let i = socialProvidersStart; i < content.length; i++) {
+          if (content[i] === "{") {
+            braceCount++;
+            inSocialProviders = true;
+          } else if (content[i] === "}") {
+            braceCount--;
+            if (inSocialProviders && braceCount === 0) {
+              socialProvidersEnd = i;
+              break;
+            }
+          }
+        }
+        const before = content.substring(0, socialProvidersEnd);
+        const after = content.substring(socialProvidersEnd);
+        content = before + `${githubProviderCode} 
+` + after;
+      } else {
+        const insertPosition = content.search(
+          /(?=,\s*(plugins|emailAndPassword|session|database|$|\n\s*\}\)))/
+        );
+        if (insertPosition !== -1) {
+          const before = content.substring(0, insertPosition);
+          const after = content.substring(insertPosition);
+          content = before + `,
+  socialProviders: {
+    ${githubProviderCode}
+  }` + after;
+        }
+      }
+      fs5.writeFileSync(authFilePath, content, "utf8");
+      const envPath = path5.join(projectDir, ".env");
+      if (fs5.existsSync(envPath)) {
+        fs5.appendFileSync(envPath, `
+
+# Github OAuth Credentials`);
+        fs5.appendFileSync(envPath, `
+GITHUB_CLIENT_ID=`);
+        fs5.appendFileSync(envPath, `
+GITHUB_CLIENT_SECRET=`);
+      }
+      const componentPath = path5.resolve(
+        __dirname,
+        "./template/components/GithubProviders.tsx"
+      );
+      const destinationPath = path5.join(
+        projectDir,
+        folder,
+        "components",
+        "authverse"
+      );
+      if (!fs5.existsSync(destinationPath)) {
+        fs5.mkdirSync(destinationPath, { recursive: true });
+      }
+      const LoginDestinationPath = path5.join(
+        destinationPath,
+        "GithubProviders.tsx"
+      );
+      if (fs5.existsSync(componentPath)) {
+        fs5.copyFileSync(componentPath, LoginDestinationPath);
+      }
+      console.log(
+        chalk5.green("Added socialProviders with Github provider successfully")
+      );
+    } else {
+      console.log(chalk5.red("Could not find betterAuth({ }) block in auth.ts"));
+    }
+  } catch (error) {
+    console.log(chalk5.red("Error adding socialProviders:"), error);
+  }
+};
+
+// cli/provider.ts
+var providers = async ({ provider }) => {
+  try {
+    if (provider == "google") {
+      await googleRun();
+    } else if (provider == "github") {
+      await githubRun();
+    }
+  } catch (error) {
+    console.log(chalk6.red("Error adding provider:"), error);
+  }
+};
+
+// cli/forget.ts
+import chalk7 from "chalk";
+import { execSync as execSync6 } from "child_process";
+import path6 from "path";
+import { fileURLToPath as fileURLToPath6 } from "url";
+import fs6 from "fs";
+var forget = async () => {
+  try {
+    execSync6("npm install @react-email/components resend", {
+      stdio: "inherit"
+    });
+    const __filename = fileURLToPath6(import.meta.url);
+    const __dirname = path6.dirname(__filename);
+    const projectDir = process.cwd();
+    const srcPath = path6.join(projectDir, "src");
+    const folder = fs6.existsSync(srcPath) ? "src" : "";
+    const authFilePath = path6.join(projectDir, folder, "lib", "auth.ts");
+    if (!fs6.existsSync(authFilePath)) {
+      console.log(chalk7.red("auth.ts file not found."));
+      return;
+    }
+    let content = fs6.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;
+      }
+      fs6.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;
+        fs6.writeFileSync(authFilePath, content, "utf8");
+      }
+      const envPath = path6.join(projectDir, ".env");
+      if (fs6.existsSync(envPath)) {
+        fs6.appendFileSync(envPath, `
+
+# Resend API Key for sending emails`);
+        fs6.appendFileSync(envPath, `
+RESEND_API_KEY=`);
+        fs6.appendFileSync(envPath, `
+EMAIL_SENDER_NAME=Your Name`);
+        fs6.appendFileSync(envPath, `
+EMAIL_SENDER_ADDRESS=`);
+      }
+      const componentPath = path6.resolve(
+        __dirname,
+        "./template/email/reset-password.tsx"
+      );
+      const destinationPath = path6.join(
+        projectDir,
+        folder,
+        "components",
+        "email"
+      );
+      if (!fs6.existsSync(destinationPath)) {
+        fs6.mkdirSync(destinationPath, { recursive: true });
+      }
+      const emailDestinationPath = path6.join(
+        destinationPath,
+        "reset-password.tsx"
+      );
+      if (fs6.existsSync(componentPath)) {
+        fs6.copyFileSync(componentPath, emailDestinationPath);
+      }
+      const forgetComponentPath = path6.resolve(
+        __dirname,
+        "./template/components/ForgetComponent.tsx"
+      );
+      const componentsDestinationPath = path6.join(
+        projectDir,
+        folder,
+        "components",
+        "authverse"
+      );
+      if (!fs6.existsSync(componentsDestinationPath)) {
+        fs6.mkdirSync(componentsDestinationPath, { recursive: true });
+      }
+      const forgetDestinationPath = path6.join(
+        componentsDestinationPath,
+        "ForgetComponent.tsx"
+      );
+      if (fs6.existsSync(forgetComponentPath)) {
+        fs6.copyFileSync(forgetComponentPath, forgetDestinationPath);
+      }
+      const resetComponentPath = path6.resolve(
+        __dirname,
+        "./template/components/ResetComponent.tsx"
+      );
+      const resetDestinationPath = path6.join(
+        componentsDestinationPath,
+        "ResetComponent.tsx"
+      );
+      if (fs6.existsSync(resetComponentPath)) {
+        fs6.copyFileSync(resetComponentPath, resetDestinationPath);
+      }
+      const authTemplatePath = path6.resolve(
+        __dirname,
+        "./template/app-auth-uiDesign"
+      );
+      const appDestinationPath = path6.join(projectDir, folder, "app", "auth");
+      if (!fs6.existsSync(appDestinationPath)) {
+        fs6.mkdirSync(appDestinationPath, { recursive: true });
+      }
+      const forgetDestinationDir = path6.join(appDestinationPath, "forget");
+      if (!fs6.existsSync(forgetDestinationDir)) {
+        fs6.mkdirSync(forgetDestinationDir, { recursive: true });
+      }
+      const forgetPageDestinationPath = path6.join(
+        forgetDestinationDir,
+        "page.tsx"
+      );
+      fs6.copyFileSync(
+        `${authTemplatePath}/forget/page.tsx`,
+        forgetPageDestinationPath
+      );
+      const resetDestinationDir = path6.join(
+        appDestinationPath,
+        "reset-password"
+      );
+      if (!fs6.existsSync(resetDestinationDir)) {
+        fs6.mkdirSync(resetDestinationDir, { recursive: true });
+      }
+      const resetPageDestinationPath = path6.join(
+        resetDestinationDir,
+        "page.tsx"
+      );
+      fs6.copyFileSync(
+        `${authTemplatePath}/reset-password/page.tsx`,
+        resetPageDestinationPath
+      );
+      console.log(
+        chalk7.green("Added sendResetPassword configuration successfully")
+      );
+    } else {
+      console.log(
+        chalk7.red("Could not find emailAndPassword configuration in auth.ts")
+      );
+    }
+  } catch (error) {
+    console.log(chalk7.red("Error adding sendResetPassword:"), error);
+  }
+};
+
+// script/detect-nextjs.ts
+import { existsSync, readFileSync } from "fs";
+function isNextJsProject() {
+  if (!existsSync("./package.json")) return false;
+  try {
+    const pkg = JSON.parse(readFileSync("./package.json", "utf8"));
+    const deps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    return deps["next"] !== void 0;
+  } catch (err) {
+    return false;
+  }
+}
+
+// index.ts
+import chalk8 from "chalk";
+var packageJson = JSON.parse(readFileSync2("./package.json", "utf8"));
+var program = new Command();
+program.name("authverse").description("CLI tool for creating authverse projects").version(
+  packageJson.version || "1.0.0",
+  "-v, --version",
+  "display the version number"
+);
+program.command("init").description("Select project template and configuration").action(() => {
+  if (!isNextJsProject) {
+    console.log(chalk8.red("Only Next.js projects are supported."));
+    process.exit(1);
+  }
+  initAnswer();
+});
+program.command("add <provider>").description("Add a new authentication provider").action((provider) => providers({ provider }));
+program.command("forget").description("Forget stored configurations").action(forget);
+program.parse(process.argv);