@reliverse/dler 1.7.92 → 1.7.94

package/bin/app/better/auth/init/cmd.js

@@ -0,0 +1,979 @@
+import { re } from "@reliverse/relico";
+import { existsSync } from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import {
+  cancel,
+  confirm,
+  defineCommand,
+  intro,
+  isCancel,
+  multiselect,
+  outro,
+  select,
+  selectSimple,
+  spinner,
+  text
+} from "@reliverse/rempts";
+import { parse } from "dotenv";
+import { execaCommand } from "execa";
+import fs from "fs/promises";
+import path from "path";
+import semver from "semver";
+import { z } from "zod";
+import { generateAuthConfig } from "../(generators)/auth-config.js";
+import { checkPackageManagers } from "../(utils)/check-package-managers.js";
+import { formatMilliseconds } from "../(utils)/format-ms.js";
+import { generateSecretHash } from "../(utils)/generate-secret.js";
+import { getPackageInfo } from "../(utils)/get-package-info.js";
+import { getTsconfigInfo } from "../(utils)/get-tsconfig-info.js";
+import { installDependencies } from "../(utils)/install-dependencies.js";
+const supportedDatabases = [
+  // Built-in kysely
+  "sqlite",
+  "mysql",
+  "mssql",
+  "postgres",
+  // Drizzle
+  "drizzle:pg",
+  "drizzle:mysql",
+  "drizzle:sqlite",
+  // Prisma
+  "prisma:postgresql",
+  "prisma:mysql",
+  "prisma:sqlite",
+  // Mongo
+  "mongodb"
+];
+export const supportedPlugins = [
+  {
+    id: "two-factor",
+    name: "twoFactor",
+    path: `better-auth/plugins`,
+    clientName: "twoFactorClient",
+    clientPath: "better-auth/client/plugins"
+  },
+  {
+    id: "username",
+    name: "username",
+    clientName: "usernameClient",
+    path: `better-auth/plugins`,
+    clientPath: "better-auth/client/plugins"
+  },
+  {
+    id: "anonymous",
+    name: "anonymous",
+    clientName: "anonymousClient",
+    path: `better-auth/plugins`,
+    clientPath: "better-auth/client/plugins"
+  },
+  {
+    id: "phone-number",
+    name: "phoneNumber",
+    clientName: "phoneNumberClient",
+    path: `better-auth/plugins`,
+    clientPath: "better-auth/client/plugins"
+  },
+  {
+    id: "magic-link",
+    name: "magicLink",
+    clientName: "magicLinkClient",
+    clientPath: "better-auth/client/plugins",
+    path: `better-auth/plugins`
+  },
+  {
+    id: "email-otp",
+    name: "emailOTP",
+    clientName: "emailOTPClient",
+    path: `better-auth/plugins`,
+    clientPath: "better-auth/client/plugins"
+  },
+  {
+    id: "passkey",
+    name: "passkey",
+    clientName: "passkeyClient",
+    path: `better-auth/plugins/passkey`,
+    clientPath: "better-auth/client/plugins"
+  },
+  {
+    id: "generic-oauth",
+    name: "genericOAuth",
+    clientName: "genericOAuthClient",
+    path: `better-auth/plugins`,
+    clientPath: "better-auth/client/plugins"
+  },
+  {
+    id: "one-tap",
+    name: "oneTap",
+    clientName: "oneTapClient",
+    path: `better-auth/plugins`,
+    clientPath: "better-auth/client/plugins"
+  },
+  {
+    id: "api-key",
+    name: "apiKey",
+    clientName: "apiKeyClient",
+    path: `better-auth/plugins`,
+    clientPath: "better-auth/client/plugins"
+  },
+  {
+    id: "admin",
+    name: "admin",
+    clientName: "adminClient",
+    path: `better-auth/plugins`,
+    clientPath: "better-auth/client/plugins"
+  },
+  {
+    id: "organization",
+    name: "organization",
+    clientName: "organizationClient",
+    path: `better-auth/plugins`,
+    clientPath: "better-auth/client/plugins"
+  },
+  {
+    id: "oidc",
+    name: "oidcProvider",
+    clientName: "oidcClient",
+    path: `better-auth/plugins`,
+    clientPath: "better-auth/client/plugins"
+  },
+  {
+    id: "sso",
+    name: "sso",
+    clientName: "ssoClient",
+    path: `better-auth/plugins/sso`,
+    clientPath: "better-auth/client/plugins"
+  },
+  {
+    id: "bearer",
+    name: "bearer",
+    clientName: void 0,
+    path: `better-auth/plugins`,
+    clientPath: void 0
+  },
+  {
+    id: "multi-session",
+    name: "multiSession",
+    clientName: "multiSessionClient",
+    path: `better-auth/plugins`,
+    clientPath: "better-auth/client/plugins"
+  },
+  {
+    id: "oauth-proxy",
+    name: "oAuthProxy",
+    clientName: void 0,
+    path: `better-auth/plugins`,
+    clientPath: void 0
+  },
+  {
+    id: "open-api",
+    name: "openAPI",
+    clientName: void 0,
+    path: `better-auth/plugins`,
+    clientPath: void 0
+  },
+  {
+    id: "jwt",
+    name: "jwt",
+    clientName: void 0,
+    clientPath: void 0,
+    path: `better-auth/plugins`
+  },
+  {
+    id: "next-cookies",
+    name: "nextCookies",
+    clientPath: void 0,
+    clientName: void 0,
+    path: `better-auth/next-js`
+  }
+];
+async function formatWithBiome(code, _filepath) {
+  const tempFile = path.join(process.cwd(), `.temp-${Date.now()}.ts`);
+  try {
+    await fs.writeFile(tempFile, code);
+    await execaCommand(`bun x biome format --write ${tempFile}`);
+    const formatted = await fs.readFile(tempFile, "utf-8");
+    return formatted;
+  } finally {
+    await fs.unlink(tempFile).catch(() => {
+    });
+  }
+}
+const getDefaultAuthConfig = async ({ appName }) => await formatWithBiome(
+  [
+    "import { betterAuth } from 'better-auth';",
+    "",
+    "export const auth = betterAuth({",
+    appName ? `appName: "${appName}",` : "",
+    "plugins: [],",
+    "});"
+  ].join("\n"),
+  "auth.ts"
+);
+const getDefaultAuthClientConfig = async ({
+  auth_config_path,
+  framework,
+  clientPlugins
+}) => {
+  function groupImportVariables() {
+    const result = [
+      {
+        path: "better-auth/client/plugins",
+        variables: [{ name: "inferAdditionalFields" }]
+      }
+    ];
+    for (const plugin of clientPlugins) {
+      for (const import_ of plugin.imports) {
+        if (Array.isArray(import_.variables)) {
+          for (const variable of import_.variables) {
+            const existingIndex = result.findIndex((x) => x.path === import_.path);
+            if (existingIndex !== -1) {
+              const vars = result[existingIndex].variables;
+              if (Array.isArray(vars)) {
+                vars.push(variable);
+              } else {
+                result[existingIndex].variables = [vars, variable];
+              }
+            } else {
+              result.push({
+                path: import_.path,
+                variables: [variable]
+              });
+            }
+          }
+        } else {
+          const existingIndex = result.findIndex((x) => x.path === import_.path);
+          if (existingIndex !== -1) {
+            const vars = result[existingIndex].variables;
+            if (Array.isArray(vars)) {
+              vars.push(import_.variables);
+            } else {
+              result[existingIndex].variables = [vars, import_.variables];
+            }
+          } else {
+            result.push({
+              path: import_.path,
+              variables: [import_.variables]
+            });
+          }
+        }
+      }
+    }
+    return result;
+  }
+  const imports = groupImportVariables();
+  let importString = "";
+  for (const import_ of imports) {
+    if (Array.isArray(import_.variables)) {
+      importString += `import { ${import_.variables.map((x) => `${x.asType ? "type " : ""}${x.name}${x.as ? ` as ${x.as}` : ""}`).join(", ")} } from "${import_.path}";
+`;
+    } else {
+      importString += `import ${import_.variables.asType ? "type " : ""}${import_.variables.name}${import_.variables.as ? ` as ${import_.variables.as}` : ""} from "${import_.path}";
+`;
+    }
+  }
+  const formattedCode = await formatWithBiome(
+    [
+      `import { createAuthClient } from "better-auth/${framework === "nextjs" ? "react" : framework === "vanilla" ? "client" : framework}";`,
+      `import type { auth } from "${auth_config_path}";`,
+      importString,
+      ``,
+      `export const authClient = createAuthClient({`,
+      `baseURL: "http://localhost:3000",`,
+      `plugins: [inferAdditionalFields<typeof auth>(),${clientPlugins.map((x) => `${x.name}(${x.contents})`).join(", ")}],`,
+      `});`
+    ].join("\n"),
+    "auth-client.ts"
+  );
+  return formattedCode;
+};
+const optionsSchema = z.object({
+  cwd: z.string(),
+  config: z.string().optional(),
+  database: z.enum(supportedDatabases).optional(),
+  "skip-db": z.boolean().optional(),
+  "skip-plugins": z.boolean().optional(),
+  "package-manager": z.string().optional(),
+  tsconfig: z.string().optional()
+});
+const outroText = `\u{1F973} All Done, Happy Hacking!`;
+export const init = defineCommand({
+  meta: {
+    name: "init",
+    description: "Initialize Better Auth in your project"
+  },
+  args: {
+    cwd: {
+      type: "string",
+      description: "The working directory",
+      default: process.cwd()
+    },
+    config: {
+      type: "string",
+      description: "The path to the auth configuration file. defaults to the first `auth.ts` file found.",
+      optional: true
+    },
+    tsconfig: {
+      type: "string",
+      description: "The path to the tsconfig file",
+      optional: true
+    },
+    "skip-db": {
+      type: "boolean",
+      description: "Skip the database setup",
+      optional: true
+    },
+    "skip-plugins": {
+      type: "boolean",
+      description: "Skip the plugins setup",
+      optional: true
+    },
+    "package-manager": {
+      type: "string",
+      description: "The package manager you want to use",
+      optional: true
+    }
+  },
+  async run({ args }) {
+    console.log();
+    intro("\u{1F44B} Initializing Better Auth");
+    const options = optionsSchema.parse(args);
+    const cwd = path.resolve(options.cwd);
+    let packageManagerPreference;
+    let config_path = "";
+    let framework = "vanilla";
+    const format = async (code) => await formatWithBiome(code, config_path);
+    let packageInfo;
+    try {
+      packageInfo = getPackageInfo(cwd);
+    } catch (error) {
+      relinka("error", `\u274C Couldn't read your package.json file. (dir: ${cwd})`);
+      relinka("error", JSON.stringify(error, null, 2));
+      process.exit(1);
+    }
+    const envFiles = await getEnvFiles(cwd);
+    if (!envFiles.length) {
+      outro("\u274C No .env files found. Please create an env file first.");
+      process.exit(0);
+    }
+    let targetEnvFile;
+    if (envFiles.includes(".env")) targetEnvFile = ".env";
+    else if (envFiles.includes(".env.local")) targetEnvFile = ".env.local";
+    else if (envFiles.includes(".env.development")) targetEnvFile = ".env.development";
+    else if (envFiles.length === 1) targetEnvFile = envFiles[0];
+    else targetEnvFile = "none";
+    let tsconfigInfo;
+    try {
+      const tsconfigPath = options.tsconfig !== void 0 ? path.resolve(cwd, options.tsconfig) : path.join(cwd, "tsconfig.json");
+      tsconfigInfo = await getTsconfigInfo(cwd, tsconfigPath);
+    } catch (error) {
+      relinka("error", `\u274C Couldn't read your tsconfig.json file. (dir: ${cwd})`);
+      console.error(error);
+      process.exit(1);
+    }
+    if (!("compilerOptions" in tsconfigInfo && "strict" in tsconfigInfo.compilerOptions && tsconfigInfo.compilerOptions.strict === true)) {
+      relinka(
+        "warn",
+        `Better Auth requires your tsconfig.json to have "compilerOptions.strict" set to true.`
+      );
+      const shouldAdd = await confirm({
+        message: `Would you like us to set ${re.bold(`strict`)} to ${re.bold(`true`)}?`
+      });
+      if (isCancel(shouldAdd)) {
+        cancel(`\u270B Operation cancelled.`);
+        process.exit(0);
+      }
+      if (shouldAdd) {
+        try {
+          await fs.writeFile(path.join(cwd, "tsconfig.json"), "utf-8");
+          relinka("success", `\u{1F680} tsconfig.json successfully updated!`);
+        } catch (error) {
+          relinka("error", `Failed to add "compilerOptions.strict" to your tsconfig.json file.`);
+          console.error(error);
+          process.exit(1);
+        }
+      }
+    }
+    const s = spinner({ indicator: "dots", text: "Checking better-auth installation" });
+    s.start(`Checking better-auth installation`);
+    let latest_betterauth_version;
+    try {
+      latest_betterauth_version = await getLatestNpmVersion("better-auth");
+    } catch (error) {
+      relinka("error", `\u274C Couldn't get latest version of better-auth.`);
+      console.error(error);
+      process.exit(1);
+    }
+    if (!packageInfo.dependencies || !Object.keys(packageInfo.dependencies).includes("better-auth")) {
+      s.stop("Finished fetching latest version of better-auth.");
+      const s2 = spinner({ indicator: "dots", text: "Installing Better Auth" });
+      const shouldInstallBetterAuthDep = await confirm({
+        message: `Would you like to install Better Auth?`
+      });
+      if (isCancel(shouldInstallBetterAuthDep)) {
+        cancel(`\u270B Operation cancelled.`);
+        process.exit(0);
+      }
+      if (packageManagerPreference === void 0) {
+        packageManagerPreference = await getPackageManager();
+      }
+      if (shouldInstallBetterAuthDep) {
+        s2.start(`Installing Better Auth using ${re.bold(packageManagerPreference)}`);
+        try {
+          const start = Date.now();
+          await installDependencies({
+            dependencies: ["better-auth@latest"],
+            packageManager: packageManagerPreference,
+            cwd
+          });
+          s2.stop(
+            `Better Auth installed ${re.greenBright(
+              `successfully`
+            )}! ${re.gray(`(${formatMilliseconds(Date.now() - start)})`)}`
+          );
+        } catch (error) {
+          s2.stop(`Failed to install Better Auth:`);
+          console.error(error);
+          process.exit(1);
+        }
+      }
+    } else if (packageInfo.dependencies["better-auth"] !== "workspace:*" && semver.lt(
+      semver.coerce(packageInfo.dependencies["better-auth"])?.toString() ?? "",
+      semver.clean(latest_betterauth_version) ?? ""
+    )) {
+      s.stop("Finished fetching latest version of better-auth.");
+      const shouldInstallBetterAuthDep = await confirm({
+        message: `Your current Better Auth dependency is out-of-date. Would you like to update it? (${re.bold(
+          packageInfo.dependencies["better-auth"]
+        )} \u2192 ${re.bold(`v${latest_betterauth_version}`)})`
+      });
+      if (isCancel(shouldInstallBetterAuthDep)) {
+        cancel(`\u270B Operation cancelled.`);
+        process.exit(0);
+      }
+      if (shouldInstallBetterAuthDep) {
+        if (packageManagerPreference === void 0) {
+          packageManagerPreference = await getPackageManager();
+        }
+        const s2 = spinner({ indicator: "dots", text: "Updating Better Auth" });
+        s2.start(`Updating Better Auth using ${re.bold(packageManagerPreference)}`);
+        try {
+          const start = Date.now();
+          await installDependencies({
+            dependencies: ["better-auth@latest"],
+            packageManager: packageManagerPreference,
+            cwd
+          });
+          s2.stop(
+            `Better Auth updated ${re.greenBright(
+              `successfully`
+            )}! ${re.gray(`(${formatMilliseconds(Date.now() - start)})`)}`
+          );
+        } catch (error) {
+          s2.stop(`Failed to update Better Auth:`);
+          relinka("error", error.message);
+          process.exit(1);
+        }
+      }
+    } else {
+      s.stop(`Better Auth dependencies are ${re.greenBright(`up to date`)}!`);
+    }
+    const packageJson = getPackageInfo(cwd);
+    let appName;
+    if (!packageJson.name) {
+      const newAppName = await text({
+        message: "What is the name of your application?"
+      });
+      if (isCancel(newAppName)) {
+        cancel("\u270B Operation cancelled.");
+        process.exit(0);
+      }
+      appName = newAppName;
+    } else {
+      appName = packageJson.name;
+    }
+    let possiblePaths = ["auth.ts", "auth.tsx", "auth.js", "auth.jsx"];
+    possiblePaths = [
+      ...possiblePaths,
+      ...possiblePaths.map((it) => `lib/server/${it}`),
+      ...possiblePaths.map((it) => `server/${it}`),
+      ...possiblePaths.map((it) => `lib/${it}`),
+      ...possiblePaths.map((it) => `utils/${it}`)
+    ];
+    possiblePaths = [
+      ...possiblePaths,
+      ...possiblePaths.map((it) => `src/${it}`),
+      ...possiblePaths.map((it) => `app/${it}`)
+    ];
+    if (options.config) {
+      config_path = path.join(cwd, options.config);
+    } else {
+      for (const possiblePath of possiblePaths) {
+        const doesExist = existsSync(path.join(cwd, possiblePath));
+        if (doesExist) {
+          config_path = path.join(cwd, possiblePath);
+          break;
+        }
+      }
+    }
+    let current_user_config = "";
+    let database = null;
+    let add_plugins = [];
+    if (!config_path) {
+      const shouldCreateAuthConfig = await select({
+        message: `Would you like to create an auth config file?`,
+        options: [
+          { label: "Yes", value: "yes" },
+          { label: "No", value: "no" }
+        ]
+      });
+      if (isCancel(shouldCreateAuthConfig)) {
+        cancel(`\u270B Operation cancelled.`);
+        process.exit(0);
+      }
+      if (shouldCreateAuthConfig === "yes") {
+        const shouldSetupDb = await confirm({
+          message: `Would you like to set up your ${re.bold(`database`)}?`,
+          initialValue: true
+        });
+        if (isCancel(shouldSetupDb)) {
+          cancel(`\u270B Operating cancelled.`);
+          process.exit(0);
+        }
+        if (shouldSetupDb) {
+          const prompted_database = await select({
+            message: "Choose a Database Dialect",
+            options: supportedDatabases.map((it) => ({ value: it, label: it }))
+          });
+          if (isCancel(prompted_database)) {
+            cancel(`\u270B Operating cancelled.`);
+            process.exit(0);
+          }
+          database = prompted_database;
+        }
+        if (options["skip-plugins"] !== false) {
+          const shouldSetupPlugins = await confirm({
+            message: `Would you like to set up ${re.bold(`plugins`)}?`
+          });
+          if (isCancel(shouldSetupPlugins)) {
+            cancel(`\u270B Operating cancelled.`);
+            process.exit(0);
+          }
+          if (shouldSetupPlugins) {
+            const prompted_plugins = await multiselect({
+              message: "Select your new plugins",
+              options: supportedPlugins.filter((x) => x.id !== "next-cookies").map((x) => ({ value: x.id, label: x.id })),
+              required: false
+            });
+            if (isCancel(prompted_plugins)) {
+              cancel(`\u270B Operating cancelled.`);
+              process.exit(0);
+            }
+            add_plugins = prompted_plugins.map((x) => supportedPlugins.find((y) => y.id === x));
+            const possible_next_config_paths = [
+              "next.config.js",
+              "next.config.ts",
+              "next.config.mjs",
+              ".next/server/next.config.js",
+              ".next/server/next.config.ts",
+              ".next/server/next.config.mjs"
+            ];
+            for (const possible_next_config_path of possible_next_config_paths) {
+              if (existsSync(path.join(cwd, possible_next_config_path))) {
+                framework = "nextjs";
+                break;
+              }
+            }
+            if (framework === "nextjs") {
+              const result = await confirm({
+                message: `It looks like you're using NextJS. Do you want to add the next-cookies plugin? ${re.bold(
+                  `(Recommended)`
+                )}`
+              });
+              if (isCancel(result)) {
+                cancel(`\u270B Operating cancelled.`);
+                process.exit(0);
+              }
+              if (result) {
+                add_plugins.push(supportedPlugins.find((x) => x.id === "next-cookies"));
+              }
+            }
+          }
+        }
+        const filePath = path.join(cwd, "auth.ts");
+        config_path = filePath;
+        relinka("info", `Creating auth config file: ${filePath}`);
+        try {
+          current_user_config = await getDefaultAuthConfig({
+            appName
+          });
+          const { dependencies, envs, generatedCode } = await generateAuthConfig({
+            current_user_config,
+            format,
+            // @ts-expect-error TODO: fix ts
+            s,
+            plugins: add_plugins,
+            database
+          });
+          current_user_config = generatedCode;
+          await fs.writeFile(filePath, current_user_config);
+          config_path = filePath;
+          relinka("success", `\u{1F680} Auth config file successfully created!`);
+          if (envs.length !== 0) {
+            relinka(
+              "info",
+              `There are ${envs.length} environment variables for your database of choice.`
+            );
+            const shouldUpdateEnvs = await confirm({
+              message: `Would you like us to update your ENV files?`
+            });
+            if (isCancel(shouldUpdateEnvs)) {
+              cancel("\u270B Operation cancelled.");
+              process.exit(0);
+            }
+            if (shouldUpdateEnvs) {
+              const filesToUpdate = await multiselect({
+                message: "Select the .env files you want to update",
+                options: envFiles.map((x) => ({
+                  value: path.join(cwd, x),
+                  label: x
+                })),
+                required: false
+              });
+              if (isCancel(filesToUpdate)) {
+                cancel("\u270B Operation cancelled.");
+                process.exit(0);
+              }
+              if (filesToUpdate.length === 0) {
+                relinka("info", "No .env files to update. Skipping...");
+              } else {
+                try {
+                  await updateEnvs({
+                    files: filesToUpdate,
+                    envs,
+                    isCommented: true
+                  });
+                } catch (error) {
+                  relinka("error", `Failed to update .env files:`);
+                  relinka("error", JSON.stringify(error, null, 2));
+                  process.exit(1);
+                }
+                relinka("success", `\u{1F680} ENV files successfully updated!`);
+              }
+            }
+          }
+          if (dependencies.length !== 0) {
+            relinka(
+              "info",
+              `There are ${dependencies.length} dependencies to install. (${dependencies.map((x) => re.green(x)).join(", ")})`
+            );
+            const shouldInstallDeps = await confirm({
+              message: `Would you like us to install dependencies?`
+            });
+            if (isCancel(shouldInstallDeps)) {
+              cancel("\u270B Operation cancelled.");
+              process.exit(0);
+            }
+            if (shouldInstallDeps) {
+              const s2 = spinner({ indicator: "dots", text: "Installing dependencies" });
+              if (packageManagerPreference === void 0) {
+                packageManagerPreference = await getPackageManager();
+              }
+              s2.start(`Installing dependencies using ${re.bold(packageManagerPreference)}...`);
+              try {
+                const start = Date.now();
+                await installDependencies({
+                  dependencies,
+                  packageManager: packageManagerPreference,
+                  cwd
+                });
+                s2.stop(
+                  `Dependencies installed ${re.greenBright(
+                    `successfully`
+                  )} ${re.gray(`(${formatMilliseconds(Date.now() - start)})`)}`
+                );
+              } catch (error) {
+                s2.stop(`Failed to install dependencies using ${packageManagerPreference}:`);
+                relinka("error", error.message);
+                process.exit(1);
+              }
+            }
+          }
+        } catch (error) {
+          relinka("error", `Failed to create auth config file: ${filePath}`);
+          console.error(error);
+          process.exit(1);
+        }
+      } else if (shouldCreateAuthConfig === "no") {
+        relinka("info", `Skipping auth config file creation.`);
+      }
+    } else {
+      relinka("success", `Found auth config file. ${re.gray(`(${config_path})`)}`);
+    }
+    let possibleClientPaths = [
+      "auth-client.ts",
+      "auth-client.tsx",
+      "auth-client.js",
+      "auth-client.jsx",
+      "client.ts",
+      "client.tsx",
+      "client.js",
+      "client.jsx"
+    ];
+    possibleClientPaths = [
+      ...possibleClientPaths,
+      ...possibleClientPaths.map((it) => `lib/server/${it}`),
+      ...possibleClientPaths.map((it) => `server/${it}`),
+      ...possibleClientPaths.map((it) => `lib/${it}`),
+      ...possibleClientPaths.map((it) => `utils/${it}`)
+    ];
+    possibleClientPaths = [
+      ...possibleClientPaths,
+      ...possibleClientPaths.map((it) => `src/${it}`),
+      ...possibleClientPaths.map((it) => `app/${it}`)
+    ];
+    let authClientConfigPath = null;
+    for (const possiblePath of possibleClientPaths) {
+      const doesExist = existsSync(path.join(cwd, possiblePath));
+      if (doesExist) {
+        authClientConfigPath = path.join(cwd, possiblePath);
+        break;
+      }
+    }
+    if (!authClientConfigPath) {
+      const choice = await select({
+        message: `Would you like to create an auth client config file?`,
+        options: [
+          { label: "Yes", value: "yes" },
+          { label: "No", value: "no" }
+        ]
+      });
+      if (isCancel(choice)) {
+        cancel(`\u270B Operation cancelled.`);
+        process.exit(0);
+      }
+      if (choice === "yes") {
+        authClientConfigPath = path.join(cwd, "auth-client.ts");
+        relinka("info", `Creating auth client config file: ${authClientConfigPath}`);
+        try {
+          const contents = await getDefaultAuthClientConfig({
+            auth_config_path: `./${path.join(config_path.replace(cwd, ""))}`.replace(".//", "./"),
+            clientPlugins: add_plugins.filter((x) => x.clientName).map((plugin) => {
+              let contents2 = "";
+              if (plugin.id === "one-tap") {
+                contents2 = `{ clientId: "MY_CLIENT_ID" }`;
+              }
+              return {
+                contents: contents2,
+                id: plugin.id,
+                name: plugin.clientName,
+                imports: [
+                  {
+                    path: "better-auth/client/plugins",
+                    variables: [{ name: plugin.clientName }]
+                  }
+                ]
+              };
+            }),
+            framework
+          });
+          await fs.writeFile(authClientConfigPath, contents);
+          relinka("success", `\u{1F680} Auth client config file successfully created!`);
+        } catch (error) {
+          relinka("error", `Failed to create auth client config file: ${authClientConfigPath}`);
+          relinka("error", JSON.stringify(error, null, 2));
+          process.exit(1);
+        }
+      } else if (choice === "no") {
+        relinka("info", `Skipping auth client config file creation.`);
+      }
+    } else {
+      relinka("success", `Found auth client config file. ${re.gray(`(${authClientConfigPath})`)}`);
+    }
+    if (targetEnvFile !== "none") {
+      try {
+        const fileContents = await fs.readFile(path.join(cwd, targetEnvFile), "utf8");
+        const parsed = parse(fileContents);
+        let isMissingSecret = false;
+        let isMissingUrl = false;
+        if (parsed.BETTER_AUTH_SECRET === void 0) isMissingSecret = true;
+        if (parsed.BETTER_AUTH_URL === void 0) isMissingUrl = true;
+        if (isMissingSecret || isMissingUrl) {
+          let txt = "";
+          if (isMissingSecret && !isMissingUrl) txt = re.bold(`BETTER_AUTH_SECRET`);
+          else if (!isMissingSecret && isMissingUrl) txt = re.bold(`BETTER_AUTH_URL`);
+          else txt = `${re.underline(`BETTER_AUTH_SECRET`)} and ${re.underline(`BETTER_AUTH_URL`)}`;
+          relinka("warn", `Missing ${txt} in ${targetEnvFile}`);
+          const shouldAdd = await select({
+            message: `Do you want to add ${txt} to ${targetEnvFile}?`,
+            options: [
+              { label: "Yes", value: "yes" },
+              { label: "No", value: "no" },
+              { label: "Choose other file(s)", value: "other" }
+            ]
+          });
+          if (isCancel(shouldAdd)) {
+            cancel(`\u270B Operation cancelled.`);
+            process.exit(0);
+          }
+          const envs = [];
+          if (isMissingSecret) {
+            envs.push("BETTER_AUTH_SECRET");
+          }
+          if (isMissingUrl) {
+            envs.push("BETTER_AUTH_URL");
+          }
+          if (shouldAdd === "yes") {
+            try {
+              await updateEnvs({
+                files: [path.join(cwd, targetEnvFile)],
+                envs,
+                isCommented: false
+              });
+            } catch (error) {
+              relinka("error", `Failed to add ENV variables to ${targetEnvFile}`);
+              relinka("error", JSON.stringify(error, null, 2));
+              process.exit(1);
+            }
+            relinka("success", `\u{1F680} ENV variables successfully added!`);
+            if (isMissingUrl) {
+              relinka(
+                "info",
+                `Be sure to update your BETTER_AUTH_URL according to your app's needs.`
+              );
+            }
+          } else if (shouldAdd === "no") {
+            relinka("info", `Skipping ENV step.`);
+          } else if (shouldAdd === "other") {
+            if (!envFiles.length) {
+              cancel("No env files found. Please create an env file first.");
+              process.exit(0);
+            }
+            const envFilesToUpdate = await multiselect({
+              message: "Select the .env files you want to update",
+              options: envFiles.map((x) => ({
+                value: path.join(cwd, x),
+                label: x
+              })),
+              required: false
+            });
+            if (isCancel(envFilesToUpdate)) {
+              cancel("\u270B Operation cancelled.");
+              process.exit(0);
+            }
+            if (envFilesToUpdate.length === 0) {
+              relinka("info", "No .env files to update. Skipping...");
+            } else {
+              try {
+                await updateEnvs({
+                  files: envFilesToUpdate,
+                  envs,
+                  isCommented: false
+                });
+              } catch (error) {
+                relinka("error", `Failed to update .env files:`);
+                relinka("error", JSON.stringify(error, null, 2));
+                process.exit(1);
+              }
+              relinka("success", `\u{1F680} ENV files successfully updated!`);
+            }
+          }
+        }
+      } catch (_error) {
+      }
+    }
+    outro(outroText);
+    console.log();
+    process.exit(0);
+  }
+});
+async function getLatestNpmVersion(packageName) {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${packageName}`);
+    if (!response.ok) {
+      throw new Error(`Package not found: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data["dist-tags"].latest;
+  } catch (error) {
+    throw error?.message;
+  }
+}
+async function getPackageManager() {
+  const { hasBun, hasPnpm } = await checkPackageManagers();
+  if (!hasBun && !hasPnpm) return "npm";
+  const packageManagerOptions = [];
+  if (hasPnpm) {
+    packageManagerOptions.push({
+      value: "pnpm",
+      label: "pnpm",
+      hint: "recommended"
+    });
+  }
+  if (hasBun) {
+    packageManagerOptions.push({
+      value: "bun",
+      label: "bun"
+    });
+  }
+  packageManagerOptions.push({
+    value: "npm",
+    hint: "not recommended"
+  });
+  const packageManager = await selectSimple({
+    message: "Choose a package manager",
+    options: packageManagerOptions
+  });
+  if (isCancel(packageManager)) {
+    cancel(`Operation cancelled.`);
+    process.exit(0);
+  }
+  return packageManager;
+}
+async function getEnvFiles(cwd) {
+  const files = await fs.readdir(cwd);
+  return files.filter((x) => x.startsWith(".env"));
+}
+async function updateEnvs({
+  envs,
+  files,
+  isCommented
+}) {
+  let previouslyGeneratedSecret = null;
+  for (const file of files) {
+    const content = await fs.readFile(file, "utf8");
+    const lines = content.split("\n");
+    const newLines = envs.map(
+      (x) => `${isCommented ? "# " : ""}${x}=${getEnvDescription(x) ?? `"some_value"`}`
+    );
+    newLines.push("");
+    newLines.push(...lines);
+    await fs.writeFile(file, newLines.join("\n"), "utf8");
+  }
+  function getEnvDescription(env) {
+    if (env === "DATABASE_HOST") {
+      return `"The host of your database"`;
+    }
+    if (env === "DATABASE_PORT") {
+      return `"The port of your database"`;
+    }
+    if (env === "DATABASE_USER") {
+      return `"The username of your database"`;
+    }
+    if (env === "DATABASE_PASSWORD") {
+      return `"The password of your database"`;
+    }
+    if (env === "DATABASE_NAME") {
+      return `"The name of your database"`;
+    }
+    if (env === "DATABASE_URL") {
+      return `"The URL of your database"`;
+    }
+    if (env === "BETTER_AUTH_SECRET") {
+      previouslyGeneratedSecret = previouslyGeneratedSecret ?? generateSecretHash();
+      return `"${previouslyGeneratedSecret}"`;
+    }
+    if (env === "BETTER_AUTH_URL") {
+      return `"http://localhost:3000" # Your APP URL`;
+    }
+  }
+}