authverse 1.0.4

package/dist/index.cjs

@@ -0,0 +1,827 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// index.ts
+var import_commander = require("commander");
+
+// cli/init.ts
+var import_inquirer = __toESM(require("inquirer"), 1);
+
+// script/prisma.ts
+var import_url2 = require("url");
+var import_path2 = __toESM(require("path"), 1);
+var import_fs2 = __toESM(require("fs"), 1);
+var import_chalk2 = __toESM(require("chalk"), 1);
+var import_child_process2 = require("child_process");
+
+// function/GenerateSecret.ts
+var import_crypto = __toESM(require("crypto"), 1);
+var GenerateSecret = async () => {
+  const secret = import_crypto.default.randomBytes(64).toString("hex");
+  return secret;
+};
+
+// script/authUi.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var import_child_process = require("child_process");
+var import_path = __toESM(require("path"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var import_url = require("url");
+var import_meta = {};
+var authUiRun = async ({ folder }) => {
+  try {
+    console.log(import_chalk.default.yellow("\n Updating AuthUi Files\n"));
+    (0, import_child_process.execSync)("npx shadcn@latest add button sonner card field input", {
+      stdio: "inherit"
+    });
+    (0, import_child_process.execSync)("npm install react-hook-form @hookform/resolvers", {
+      stdio: "inherit"
+    });
+    const __filename = (0, import_url.fileURLToPath)(import_meta.url);
+    const __dirname = import_path.default.dirname(__filename);
+    const projectDir = process.cwd();
+    const componentPath = import_path.default.resolve(__dirname, "./template/components");
+    const destinationPath = import_path.default.join(
+      projectDir,
+      folder,
+      "components",
+      "authverse"
+    );
+    if (!import_fs.default.existsSync(destinationPath)) {
+      import_fs.default.mkdirSync(destinationPath, { recursive: true });
+    }
+    const LoginDestinationPath = import_path.default.join(
+      destinationPath,
+      "LoginComponent.tsx"
+    );
+    import_fs.default.copyFileSync(
+      `${componentPath}/LoginComponent.tsx`,
+      LoginDestinationPath
+    );
+    const SignUpDestinationPath = import_path.default.join(
+      destinationPath,
+      "SingUpComponent.tsx"
+    );
+    import_fs.default.copyFileSync(
+      `${componentPath}/SingUpComponent.tsx`,
+      SignUpDestinationPath
+    );
+    const LogoutDestinationPath = import_path.default.join(destinationPath, "Logout.tsx");
+    import_fs.default.copyFileSync(`${componentPath}/Logout.tsx`, LogoutDestinationPath);
+    const authTemplatePath = import_path.default.resolve(
+      __dirname,
+      "./template/app-auth-uiDesign"
+    );
+    const appDestinationPath = import_path.default.join(projectDir, folder, "app", "auth");
+    if (!import_fs.default.existsSync(appDestinationPath)) {
+      import_fs.default.mkdirSync(appDestinationPath, { recursive: true });
+    }
+    const layoutDestinationPath = import_path.default.join(appDestinationPath, "layout.tsx");
+    import_fs.default.copyFileSync(`${authTemplatePath}/layout.tsx`, layoutDestinationPath);
+    const loginDestinationDir = import_path.default.join(appDestinationPath, "login");
+    if (!import_fs.default.existsSync(loginDestinationDir)) {
+      import_fs.default.mkdirSync(loginDestinationDir, { recursive: true });
+    }
+    const loginPageDestinationPath = import_path.default.join(loginDestinationDir, "page.tsx");
+    import_fs.default.copyFileSync(
+      `${authTemplatePath}/login/page.tsx`,
+      loginPageDestinationPath
+    );
+    const signUpDestinationDir = import_path.default.join(appDestinationPath, "signup");
+    if (!import_fs.default.existsSync(signUpDestinationDir)) {
+      import_fs.default.mkdirSync(signUpDestinationDir, { recursive: true });
+    }
+    const signUpPageDestinationPath = import_path.default.join(
+      signUpDestinationDir,
+      "page.tsx"
+    );
+    import_fs.default.copyFileSync(
+      `${authTemplatePath}/signup/page.tsx`,
+      signUpPageDestinationPath
+    );
+    const layoutPath = import_path.default.join(projectDir, folder, "app", "layout.tsx");
+    if (import_fs.default.existsSync(layoutPath)) {
+      let layoutContent = import_fs.default.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>"
+        );
+      }
+      import_fs.default.writeFileSync(layoutPath, layoutContent, "utf-8");
+    }
+    console.log(import_chalk.default.green("\nSetup completed!\n"));
+  } catch (error) {
+    console.log(import_chalk.default.red("\nauthUi setup failed:"), error);
+  }
+};
+
+// script/prisma.ts
+var import_meta2 = {};
+var prismaRun = async ({ authUi, database }) => {
+  try {
+    console.log(import_chalk2.default.cyan("\n\u2699\uFE0F  Initializing Prisma...\n"));
+    if (database !== "Mongodb") {
+      (0, import_child_process2.execSync)("npm install prisma --save-dev", { stdio: "inherit" });
+      (0, import_child_process2.execSync)("npm install @prisma/client", { stdio: "inherit" });
+      if (database === "Mysql") {
+        (0, import_child_process2.execSync)("npm install @prisma/adapter-mariadb", { stdio: "inherit" });
+      }
+      if (database === "Postgresql") {
+        (0, import_child_process2.execSync)("npm install @prisma/adapter-pg", { stdio: "inherit" });
+      }
+    } else if (database === "Mongodb") {
+      (0, import_child_process2.execSync)("npm install prisma@6.19.0 --save-dev", { stdio: "inherit" });
+      (0, import_child_process2.execSync)("npm install @prisma/client@6.19.0", { stdio: "inherit" });
+    }
+    const projectDir = process.cwd();
+    const prismaDir = import_path2.default.join(projectDir, "prisma");
+    if (!import_fs2.default.existsSync(prismaDir)) {
+      console.log(import_chalk2.default.yellow("\n\u2699\uFE0F  Initializing Prisma...\n"));
+      (0, import_child_process2.execSync)("npx prisma init", { stdio: "inherit" });
+    }
+    const __filename = (0, import_url2.fileURLToPath)(import_meta2.url);
+    const __dirname = import_path2.default.dirname(__filename);
+    const templatePath = import_path2.default.resolve(
+      __dirname,
+      `./template/prisma/${database}/schema.prisma`
+    );
+    if (!import_fs2.default.existsSync(prismaDir)) {
+      import_fs2.default.mkdirSync(prismaDir, { recursive: true });
+    }
+    const destinationPath = import_path2.default.join(prismaDir, "schema.prisma");
+    import_fs2.default.copyFileSync(templatePath, destinationPath);
+    if (database === "Mongodb") {
+      const prismaConfigPath = import_path2.default.resolve(
+        __dirname,
+        `./template/config/prisma.config.ts`
+      );
+      const prismaConfigDestinationPath = import_path2.default.join("", "prisma.config.ts");
+      import_fs2.default.copyFileSync(prismaConfigPath, prismaConfigDestinationPath);
+    }
+    console.log(import_chalk2.default.yellow("\n\u2699\uFE0F  Initializing better-auth...\n"));
+    (0, import_child_process2.execSync)("npm install better-auth", { stdio: "inherit" });
+    const secret = await GenerateSecret();
+    const envPath = import_path2.default.join(projectDir, ".env");
+    import_fs2.default.appendFileSync(envPath, `
+
+BETTER_AUTH_SECRET=${secret}`);
+    import_fs2.default.appendFileSync(envPath, `
+BETTER_AUTH_URL=http://localhost:3000
+`);
+    console.log(import_chalk2.default.yellow("\n create folder...\n"));
+    const srcPath = import_path2.default.join(projectDir, "src");
+    const folder = srcPath ? "" : "src";
+    const libPath = import_path2.default.join(projectDir, folder, "lib");
+    if (!import_fs2.default.existsSync(libPath)) {
+      import_fs2.default.mkdirSync(libPath, { recursive: true });
+    }
+    const authTemplatePath = import_path2.default.resolve(
+      __dirname,
+      `./template/lib/${database}/auth.ts`
+    );
+    const authDestinationPath = import_path2.default.join(libPath, "auth.ts");
+    import_fs2.default.copyFileSync(authTemplatePath, authDestinationPath);
+    const authClientTemplatePath = import_path2.default.resolve(
+      __dirname,
+      "./template/lib/auth-client.ts"
+    );
+    const authClientDestinationPath = import_path2.default.join(libPath, "auth-client.ts");
+    import_fs2.default.copyFileSync(authClientTemplatePath, authClientDestinationPath);
+    const serverPath = import_path2.default.join(projectDir, folder, "server");
+    if (!import_fs2.default.existsSync(serverPath)) {
+      import_fs2.default.mkdirSync(serverPath, { recursive: true });
+    }
+    const userTemplatePath = import_path2.default.resolve(
+      __dirname,
+      "./template/server/user.ts"
+    );
+    const userDestinationPath = import_path2.default.join(serverPath, "user.ts");
+    import_fs2.default.copyFileSync(userTemplatePath, userDestinationPath);
+    const routeTemplatePath = import_path2.default.resolve(
+      __dirname,
+      "./template/api/route.ts"
+    );
+    const routeDestinationDir = import_path2.default.join(
+      projectDir,
+      "app",
+      "api",
+      "auth",
+      "[...all]"
+    );
+    if (!import_fs2.default.existsSync(routeDestinationDir)) {
+      import_fs2.default.mkdirSync(routeDestinationDir, { recursive: true });
+    }
+    const routeDestinationPath = import_path2.default.join(routeDestinationDir, "route.ts");
+    import_fs2.default.copyFileSync(routeTemplatePath, routeDestinationPath);
+    const proxyTemplatePath = import_path2.default.resolve(
+      __dirname,
+      "./template/proxy/proxy.ts"
+    );
+    const proxyDestinationDir = import_path2.default.join(projectDir, folder);
+    const proxyDestinationPath = import_path2.default.join(proxyDestinationDir, "proxy.ts");
+    import_fs2.default.copyFileSync(proxyTemplatePath, proxyDestinationPath);
+    if (authUi) {
+      await authUiRun({ folder });
+    } else {
+      console.log(
+        import_chalk2.default.green(
+          "\nPrisma setup completed successfully and better-auth installed\n"
+        )
+      );
+    }
+  } catch (err) {
+    console.error(import_chalk2.default.red("Prisma setup failed:"), err);
+  }
+};
+
+// script/drizzleRun.ts
+var import_chalk3 = __toESM(require("chalk"), 1);
+var import_child_process3 = require("child_process");
+var import_path3 = __toESM(require("path"), 1);
+var import_url3 = require("url");
+var import_fs3 = __toESM(require("fs"), 1);
+var import_meta3 = {};
+var drizzleRun = async (authUi) => {
+  try {
+    console.log(import_chalk3.default.cyan("\n\u2699\uFE0F  Initializing better auth and drizzle...\n"));
+    (0, import_child_process3.execSync)("npm install better-auth", { stdio: "inherit" });
+    (0, import_child_process3.execSync)("npm install drizzle-orm @neondatabase/serverless dotenv", {
+      stdio: "inherit"
+    });
+    (0, import_child_process3.execSync)("npm install -D drizzle-kit", { stdio: "inherit" });
+    const __filename = (0, import_url3.fileURLToPath)(import_meta3.url);
+    const __dirname = import_path3.default.dirname(__filename);
+    const projectDir = process.cwd();
+    const envPath = import_path3.default.join(projectDir, ".env");
+    if (!import_fs3.default.existsSync(envPath)) {
+      import_fs3.default.writeFileSync(envPath, "DATABASE_URL=\n");
+    }
+    const secret = await GenerateSecret();
+    import_fs3.default.appendFileSync(envPath, `
+
+BETTER_AUTH_SECRET=${secret}`);
+    import_fs3.default.appendFileSync(envPath, `
+BETTER_AUTH_URL=http://localhost:3000
+`);
+    const srcPath = import_path3.default.join(projectDir, "src");
+    const folder = srcPath ? "" : "src";
+    const libPath = import_path3.default.join(projectDir, folder, "lib");
+    if (!import_fs3.default.existsSync(libPath)) {
+      import_fs3.default.mkdirSync(libPath, { recursive: true });
+    }
+    const authTemplatePath = import_path3.default.resolve(
+      __dirname,
+      "./template/lib/auth-drizzle.ts"
+    );
+    const authDestinationPath = import_path3.default.join(libPath, "auth.ts");
+    import_fs3.default.copyFileSync(authTemplatePath, authDestinationPath);
+    const authClientTemplatePath = import_path3.default.resolve(
+      __dirname,
+      "./template/lib/auth-client.ts"
+    );
+    const authClientDestinationPath = import_path3.default.join(libPath, "auth-client.ts");
+    import_fs3.default.copyFileSync(authClientTemplatePath, authClientDestinationPath);
+    const dbTemplatePath = import_path3.default.resolve(__dirname, "./template/db");
+    const dbDir = import_path3.default.join(projectDir, folder, "db");
+    if (!import_fs3.default.existsSync(dbDir)) {
+      import_fs3.default.mkdirSync(dbDir, { recursive: true });
+    }
+    const dbDestinationPath = import_path3.default.join(dbDir, "drizzle.ts");
+    import_fs3.default.copyFileSync(`${dbTemplatePath}/drizzle.ts`, dbDestinationPath);
+    const schemaDestinationPath = import_path3.default.join(dbDir, "schema.ts");
+    import_fs3.default.copyFileSync(`${dbTemplatePath}/schema.ts`, schemaDestinationPath);
+    const drizzleConfigTemplatePath = import_path3.default.resolve(
+      __dirname,
+      "./template/config/drizzle.config.ts"
+    );
+    const drizzleConfigDestinationPath = import_path3.default.join(
+      projectDir,
+      "drizzle.config.ts"
+    );
+    import_fs3.default.copyFileSync(drizzleConfigTemplatePath, drizzleConfigDestinationPath);
+    const serverPath = import_path3.default.join(projectDir, folder, "server");
+    if (!import_fs3.default.existsSync(serverPath)) {
+      import_fs3.default.mkdirSync(serverPath, { recursive: true });
+    }
+    const userTemplatePath = import_path3.default.resolve(
+      __dirname,
+      "./template/server/user.ts"
+    );
+    const userDestinationPath = import_path3.default.join(serverPath, "user.ts");
+    import_fs3.default.copyFileSync(userTemplatePath, userDestinationPath);
+    const routeTemplatePath = import_path3.default.resolve(
+      __dirname,
+      "./template/api/route.ts"
+    );
+    const routeDestinationDir = import_path3.default.join(
+      projectDir,
+      "app",
+      "api",
+      "auth",
+      "[...all]"
+    );
+    if (!import_fs3.default.existsSync(routeDestinationDir)) {
+      import_fs3.default.mkdirSync(routeDestinationDir, { recursive: true });
+    }
+    const routeDestinationPath = import_path3.default.join(routeDestinationDir, "route.ts");
+    import_fs3.default.copyFileSync(routeTemplatePath, routeDestinationPath);
+    const proxyTemplatePath = import_path3.default.resolve(
+      __dirname,
+      "./template/proxy/proxy.ts"
+    );
+    const proxyDestinationDir = import_path3.default.join(projectDir, folder);
+    const proxyDestinationPath = import_path3.default.join(proxyDestinationDir, "proxy.ts");
+    import_fs3.default.copyFileSync(proxyTemplatePath, proxyDestinationPath);
+    if (authUi) {
+      await authUiRun({ folder });
+    } else {
+      console.log(
+        import_chalk3.default.green(
+          "\nDrizzle setup completed successfully and better-auth installed\n"
+        )
+      );
+    }
+  } catch (err) {
+    console.error(import_chalk3.default.red("Drizzle setup failed:"), err);
+  }
+};
+
+// cli/init.ts
+var initAnswer = async () => {
+  const answers = await import_inquirer.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
+    }
+  ]);
+  if (answers.orm === "Prisma") {
+    await prismaRun({
+      authUi: answers.authUi,
+      database: answers.database
+    });
+  }
+  if (answers.orm === "Drizzle") {
+    await drizzleRun(answers.authUi);
+  }
+};
+
+// index.ts
+var import_fs8 = require("fs");
+
+// cli/provider.ts
+var import_chalk6 = __toESM(require("chalk"), 1);
+
+// script/googleRun.ts
+var import_chalk4 = __toESM(require("chalk"), 1);
+var import_child_process4 = require("child_process");
+var import_fs4 = __toESM(require("fs"), 1);
+var import_path4 = __toESM(require("path"), 1);
+var import_url4 = require("url");
+var import_meta4 = {};
+var googleRun = async () => {
+  try {
+    (0, import_child_process4.execSync)("npm install react-icons --save", { stdio: "inherit" });
+    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 folder = 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("auth.ts file not found."));
+      return;
+    }
+    let content = import_fs4.default.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}`;
+      });
+      import_fs4.default.writeFileSync(authFilePath, content, "utf8");
+      const envPath = import_path4.default.join(projectDir, ".env");
+      import_fs4.default.appendFileSync(envPath, `
+
+# Google OAuth Credentials`);
+      import_fs4.default.appendFileSync(envPath, `
+GOOGLE_CLIENT_ID=`);
+      import_fs4.default.appendFileSync(envPath, `
+GOOGLE_CLIENT_SECRET=`);
+      const componentPath = import_path4.default.resolve(
+        __dirname,
+        "./template/components/GoogleProviders.tsx"
+      );
+      const destinationPath = import_path4.default.join(
+        projectDir,
+        folder,
+        "components",
+        "authverse"
+      );
+      if (!import_fs4.default.existsSync(destinationPath)) {
+        import_fs4.default.mkdirSync(destinationPath, { recursive: true });
+      }
+      const LoginDestinationPath = import_path4.default.join(
+        destinationPath,
+        "GoogleProviders.tsx"
+      );
+      import_fs4.default.copyFileSync(componentPath, LoginDestinationPath);
+      console.log(
+        import_chalk4.default.green("Added socialProviders with Google provider successfully")
+      );
+    } else {
+      console.log(import_chalk4.default.red("Could not find betterAuth({ }) block in auth.ts"));
+    }
+  } catch (error) {
+    console.log(import_chalk4.default.red("Error adding socialProviders:"), error);
+  }
+};
+
+// script/githubRun.ts
+var import_chalk5 = __toESM(require("chalk"), 1);
+var import_child_process5 = require("child_process");
+var import_fs5 = __toESM(require("fs"), 1);
+var import_path5 = __toESM(require("path"), 1);
+var import_url5 = require("url");
+var import_meta5 = {};
+var githubRun = async () => {
+  try {
+    (0, import_child_process5.execSync)("npm install react-icons --save", { stdio: "inherit" });
+    const __filename = (0, import_url5.fileURLToPath)(import_meta5.url);
+    const __dirname = import_path5.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."));
+      return;
+    }
+    let content = import_fs5.default.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;
+        }
+      }
+      import_fs5.default.writeFileSync(authFilePath, content, "utf8");
+      const envPath = import_path5.default.join(projectDir, ".env");
+      if (import_fs5.default.existsSync(envPath)) {
+        import_fs5.default.appendFileSync(envPath, `
+
+# Github OAuth Credentials`);
+        import_fs5.default.appendFileSync(envPath, `
+GITHUB_CLIENT_ID=`);
+        import_fs5.default.appendFileSync(envPath, `
+GITHUB_CLIENT_SECRET=`);
+      }
+      const componentPath = import_path5.default.resolve(
+        __dirname,
+        "./template/components/GithubProviders.tsx"
+      );
+      const destinationPath = import_path5.default.join(
+        projectDir,
+        folder,
+        "components",
+        "authverse"
+      );
+      if (!import_fs5.default.existsSync(destinationPath)) {
+        import_fs5.default.mkdirSync(destinationPath, { recursive: true });
+      }
+      const LoginDestinationPath = import_path5.default.join(
+        destinationPath,
+        "GithubProviders.tsx"
+      );
+      if (import_fs5.default.existsSync(componentPath)) {
+        import_fs5.default.copyFileSync(componentPath, LoginDestinationPath);
+      }
+      console.log(
+        import_chalk5.default.green("Added socialProviders with Github provider successfully")
+      );
+    } else {
+      console.log(import_chalk5.default.red("Could not find betterAuth({ }) block in auth.ts"));
+    }
+  } catch (error) {
+    console.log(import_chalk5.default.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(import_chalk6.default.red("Error adding provider:"), error);
+  }
+};
+
+// cli/forget.ts
+var import_chalk7 = __toESM(require("chalk"), 1);
+var import_child_process6 = require("child_process");
+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 () => {
+  try {
+    (0, import_child_process6.execSync)("npm install @react-email/components resend", {
+      stdio: "inherit"
+    });
+    const __filename = (0, import_url6.fileURLToPath)(import_meta6.url);
+    const __dirname = import_path6.default.dirname(__filename);
+    const projectDir = process.cwd();
+    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."));
+      return;
+    }
+    let content = import_fs6.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_fs6.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_fs6.default.writeFileSync(authFilePath, content, "utf8");
+      }
+      const envPath = import_path6.default.join(projectDir, ".env");
+      if (import_fs6.default.existsSync(envPath)) {
+        import_fs6.default.appendFileSync(envPath, `
+
+# Resend API Key for sending emails`);
+        import_fs6.default.appendFileSync(envPath, `
+RESEND_API_KEY=`);
+        import_fs6.default.appendFileSync(envPath, `
+EMAIL_SENDER_NAME=Your Name`);
+        import_fs6.default.appendFileSync(envPath, `
+EMAIL_SENDER_ADDRESS=`);
+      }
+      const componentPath = import_path6.default.resolve(
+        __dirname,
+        "./template/email/reset-password.tsx"
+      );
+      const destinationPath = import_path6.default.join(
+        projectDir,
+        folder,
+        "components",
+        "email"
+      );
+      if (!import_fs6.default.existsSync(destinationPath)) {
+        import_fs6.default.mkdirSync(destinationPath, { recursive: true });
+      }
+      const emailDestinationPath = import_path6.default.join(
+        destinationPath,
+        "reset-password.tsx"
+      );
+      if (import_fs6.default.existsSync(componentPath)) {
+        import_fs6.default.copyFileSync(componentPath, emailDestinationPath);
+      }
+      const forgetComponentPath = import_path6.default.resolve(
+        __dirname,
+        "./template/components/ForgetComponent.tsx"
+      );
+      const componentsDestinationPath = import_path6.default.join(
+        projectDir,
+        folder,
+        "components",
+        "authverse"
+      );
+      if (!import_fs6.default.existsSync(componentsDestinationPath)) {
+        import_fs6.default.mkdirSync(componentsDestinationPath, { recursive: true });
+      }
+      const forgetDestinationPath = import_path6.default.join(
+        componentsDestinationPath,
+        "ForgetComponent.tsx"
+      );
+      if (import_fs6.default.existsSync(forgetComponentPath)) {
+        import_fs6.default.copyFileSync(forgetComponentPath, forgetDestinationPath);
+      }
+      const resetComponentPath = import_path6.default.resolve(
+        __dirname,
+        "./template/components/ResetComponent.tsx"
+      );
+      const resetDestinationPath = import_path6.default.join(
+        componentsDestinationPath,
+        "ResetComponent.tsx"
+      );
+      if (import_fs6.default.existsSync(resetComponentPath)) {
+        import_fs6.default.copyFileSync(resetComponentPath, resetDestinationPath);
+      }
+      const authTemplatePath = import_path6.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 forgetDestinationDir = import_path6.default.join(appDestinationPath, "forget");
+      if (!import_fs6.default.existsSync(forgetDestinationDir)) {
+        import_fs6.default.mkdirSync(forgetDestinationDir, { recursive: true });
+      }
+      const forgetPageDestinationPath = import_path6.default.join(
+        forgetDestinationDir,
+        "page.tsx"
+      );
+      import_fs6.default.copyFileSync(
+        `${authTemplatePath}/forget/page.tsx`,
+        forgetPageDestinationPath
+      );
+      const resetDestinationDir = import_path6.default.join(
+        appDestinationPath,
+        "reset-password"
+      );
+      if (!import_fs6.default.existsSync(resetDestinationDir)) {
+        import_fs6.default.mkdirSync(resetDestinationDir, { recursive: true });
+      }
+      const resetPageDestinationPath = import_path6.default.join(
+        resetDestinationDir,
+        "page.tsx"
+      );
+      import_fs6.default.copyFileSync(
+        `${authTemplatePath}/reset-password/page.tsx`,
+        resetPageDestinationPath
+      );
+      console.log(
+        import_chalk7.default.green("Added sendResetPassword configuration successfully")
+      );
+    } else {
+      console.log(
+        import_chalk7.default.red("Could not find emailAndPassword configuration in auth.ts")
+      );
+    }
+  } catch (error) {
+    console.log(import_chalk7.default.red("Error adding sendResetPassword:"), error);
+  }
+};
+
+// script/detect-nextjs.ts
+var import_fs7 = require("fs");
+function isNextJsProject() {
+  if (!(0, import_fs7.existsSync)("./package.json")) return false;
+  try {
+    const pkg = JSON.parse((0, import_fs7.readFileSync)("./package.json", "utf8"));
+    const deps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    return deps["next"] !== void 0;
+  } catch (err) {
+    return false;
+  }
+}
+
+// index.ts
+var import_chalk8 = __toESM(require("chalk"), 1);
+var packageJson = JSON.parse((0, import_fs8.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",
+  "-v, --version",
+  "display the version number"
+);
+program.command("init").description("Select project template and configuration").action(() => {
+  if (!isNextJsProject) {
+    console.log(import_chalk8.default.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);