pecunia-cli 0.0.0

package/dist/index.mjs

@@ -0,0 +1,770 @@
+#!/usr/bin/env node
+import { i as getPackageInfo, n as generateSchema } from "./generators-xnsg6Fwk.mjs";
+import { Command } from "commander";
+import fs, { existsSync, readFileSync } from "node:fs";
+import fs$1 from "node:fs/promises";
+import path from "node:path";
+import { getAdapter, getMigrations } from "pecunia";
+import chalk from "chalk";
+import prompts from "prompts";
+import yoctoSpinner from "yocto-spinner";
+import * as z from "zod/v4";
+import { PecuniaError } from "@pecunia/core";
+import "prettier";
+import babelPresetReact from "@babel/preset-react";
+import babelPresetTypeScript from "@babel/preset-typescript";
+import { loadConfig } from "c12";
+import { execSync } from "node:child_process";
+import os from "node:os";
+import "@clack/prompts";
+import "dotenv";
+import "semver";
+import "dotenv/config";
+
+//#region src/utils/get-tsconfig-info.ts
+function stripJsonComments(jsonString) {
+	return jsonString.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) => g ? "" : m).replace(/,(?=\s*[}\]])/g, "");
+}
+function getTsconfigInfo(cwd, flatPath) {
+	let tsConfigPath;
+	if (flatPath) tsConfigPath = flatPath;
+	else tsConfigPath = cwd ? path.join(cwd, "tsconfig.json") : path.join("tsconfig.json");
+	try {
+		const text = fs.readFileSync(tsConfigPath, "utf-8");
+		return JSON.parse(stripJsonComments(text));
+	} catch (error) {
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/utils/get-config.ts
+let possiblePaths = [
+	"payment.ts",
+	"payment.tsx",
+	"payment.js",
+	"payment.jsx",
+	"payment.server.js",
+	"payment.server.ts",
+	"payment/index.ts",
+	"payment/index.tsx",
+	"payment/index.js",
+	"payment/index.jsx",
+	"payment/index.server.js",
+	"payment/index.server.ts"
+];
+possiblePaths = [
+	...possiblePaths,
+	...possiblePaths.map((it) => `lib/server/${it}`),
+	...possiblePaths.map((it) => `server/payment/${it}`),
+	...possiblePaths.map((it) => `server/${it}`),
+	...possiblePaths.map((it) => `payment/${it}`),
+	...possiblePaths.map((it) => `lib/${it}`),
+	...possiblePaths.map((it) => `utils/${it}`)
+];
+possiblePaths = [
+	...possiblePaths,
+	...possiblePaths.map((it) => `src/${it}`),
+	...possiblePaths.map((it) => `app/${it}`)
+];
+function resolveReferencePath(configDir, refPath) {
+	const resolvedPath = path.resolve(configDir, refPath);
+	if (refPath.endsWith(".json")) return resolvedPath;
+	if (fs.existsSync(resolvedPath)) try {
+		if (fs.statSync(resolvedPath).isFile()) return resolvedPath;
+	} catch {}
+	return path.resolve(configDir, refPath, "tsconfig.json");
+}
+function getPathAliasesRecursive(tsconfigPath, visited = /* @__PURE__ */ new Set()) {
+	if (visited.has(tsconfigPath)) return {};
+	visited.add(tsconfigPath);
+	if (!fs.existsSync(tsconfigPath)) {
+		console.warn(`Referenced tsconfig not found: ${tsconfigPath}`);
+		return {};
+	}
+	try {
+		const tsConfig = getTsconfigInfo(void 0, tsconfigPath);
+		const { paths = {}, baseUrl = "." } = tsConfig.compilerOptions || {};
+		const result = {};
+		const configDir = path.dirname(tsconfigPath);
+		const obj = Object.entries(paths);
+		for (const [alias, aliasPaths] of obj) for (const aliasedPath of aliasPaths) {
+			const resolvedBaseUrl = path.resolve(configDir, baseUrl);
+			const finalAlias = alias.slice(-1) === "*" ? alias.slice(0, -1) : alias;
+			const finalAliasedPath = aliasedPath.slice(-1) === "*" ? aliasedPath.slice(0, -1) : aliasedPath;
+			result[finalAlias || ""] = path.join(resolvedBaseUrl, finalAliasedPath);
+		}
+		if (tsConfig.references) for (const ref of tsConfig.references) {
+			const refAliases = getPathAliasesRecursive(resolveReferencePath(configDir, ref.path), visited);
+			for (const [alias, aliasPath] of Object.entries(refAliases)) if (!(alias in result)) result[alias] = aliasPath;
+		}
+		return result;
+	} catch (error) {
+		console.warn(`Error parsing tsconfig at ${tsconfigPath}: ${error}`);
+		return {};
+	}
+}
+function getPathAliases(cwd) {
+	const tsConfigPath = path.join(cwd, "tsconfig.json");
+	if (!fs.existsSync(tsConfigPath)) return null;
+	try {
+		const result = getPathAliasesRecursive(tsConfigPath);
+		addSvelteKitEnvModules(result);
+		addCloudflareModules(result);
+		return result;
+	} catch (error) {
+		console.error(error);
+		throw new PecuniaError("Error parsing tsconfig.json");
+	}
+}
+/**
+* .tsx files are not supported by Jiti.
+*/
+const jitiOptions = (cwd) => {
+	const alias = getPathAliases(cwd) || {};
+	return {
+		transformOptions: { babel: { presets: [[babelPresetTypeScript, {
+			isTSX: true,
+			allExtensions: true
+		}], [babelPresetReact, { runtime: "automatic" }]] } },
+		extensions: [
+			".ts",
+			".tsx",
+			".js",
+			".jsx"
+		],
+		alias
+	};
+};
+const isDefaultExport = (object) => {
+	return typeof object === "object" && object !== null && !Array.isArray(object) && Object.keys(object).length > 0 && "options" in object;
+};
+async function getConfig({ cwd, configPath, shouldThrowOnError = false }) {
+	try {
+		let configFile = null;
+		if (configPath) {
+			let resolvedPath = path.join(cwd, configPath);
+			if (existsSync(configPath)) resolvedPath = configPath;
+			const { config } = await loadConfig({
+				configFile: resolvedPath,
+				dotenv: true,
+				jitiOptions: jitiOptions(cwd),
+				cwd
+			});
+			if (!("auth" in config) && !isDefaultExport(config)) {
+				if (shouldThrowOnError) throw new Error(`Couldn't read your auth config in ${resolvedPath}. Make sure to default export your auth instance or to export as a variable named auth.`);
+				console.error(`[#better-auth]: Couldn't read your auth config in ${resolvedPath}. Make sure to default export your auth instance or to export as a variable named auth.`);
+				process.exit(1);
+			}
+			configFile = "auth" in config ? config.auth?.options : config.options;
+		}
+		if (!configFile) for (const possiblePath of possiblePaths) try {
+			const { config } = await loadConfig({
+				configFile: possiblePath,
+				jitiOptions: jitiOptions(cwd),
+				cwd
+			});
+			if (Object.keys(config).length > 0) {
+				configFile = config.auth?.options || config.default?.options || null;
+				if (!configFile) {
+					if (shouldThrowOnError) throw new Error("Couldn't read your auth config. Make sure to default export your auth instance or to export as a variable named auth.");
+					console.error("[#better-auth]: Couldn't read your auth config.");
+					console.log("");
+					console.log("[#better-auth]: Make sure to default export your auth instance or to export as a variable named auth.");
+					process.exit(1);
+				}
+				break;
+			}
+		} catch (e) {
+			if (typeof e === "object" && e && "message" in e && typeof e.message === "string" && e.message.includes("This module cannot be imported from a Client Component module")) {
+				if (shouldThrowOnError) throw new Error(`Please remove import 'server-only' from your auth config file temporarily. The CLI cannot resolve the configuration with it included. You can re-add it after running the CLI.`);
+				console.error(`Please remove import 'server-only' from your auth config file temporarily. The CLI cannot resolve the configuration with it included. You can re-add it after running the CLI.`);
+				process.exit(1);
+			}
+			if (shouldThrowOnError) throw e;
+			console.error("[#better-auth]: Couldn't read your auth config.", e);
+			process.exit(1);
+		}
+		return configFile;
+	} catch (e) {
+		if (typeof e === "object" && e && "message" in e && typeof e.message === "string" && e.message.includes("This module cannot be imported from a Client Component module")) {
+			if (shouldThrowOnError) throw new Error(`Please remove import 'server-only' from your auth config file temporarily. The CLI cannot resolve the configuration with it included. You can re-add it after running the CLI.`);
+			console.error(`Please remove import 'server-only' from your auth config file temporarily. The CLI cannot resolve the configuration with it included. You can re-add it after running the CLI.`);
+			process.exit(1);
+		}
+		if (shouldThrowOnError) throw e;
+		console.error("Couldn't read your auth config.", e);
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/commands/generate.ts
+async function generateAction(opts) {
+	const options = z.object({
+		cwd: z.string(),
+		config: z.string().optional(),
+		output: z.string().optional(),
+		y: z.boolean().optional(),
+		yes: z.boolean().optional()
+	}).parse(opts);
+	const cwd = path.resolve(options.cwd);
+	if (!existsSync(cwd)) {
+		console.error(`The directory "${cwd}" does not exist.`);
+		process.exit(1);
+	}
+	const config = await getConfig({
+		cwd,
+		configPath: options.config
+	});
+	if (!config) {
+		console.error("No configuration file found. Add a `auth.ts` file to your project or pass the path to the configuration file using the `--config` flag.");
+		return;
+	}
+	const adapter = await getAdapter(config).catch((e) => {
+		console.error(e.message);
+		process.exit(1);
+	});
+	const spinner = yoctoSpinner({ text: "preparing schema..." }).start();
+	const schema = await generateSchema({
+		adapter,
+		file: options.output,
+		options: config
+	});
+	spinner.stop();
+	if (!schema.code) {
+		console.log("Your schema is already up to date.");
+		try {
+			await (await createTelemetry(config)).publish({
+				type: "cli_generate",
+				payload: {
+					outcome: "no_changes",
+					config: getTelemetryAuthConfig(config, {
+						adapter: adapter.id,
+						database: typeof config.database === "function" ? "adapter" : "kysely"
+					})
+				}
+			});
+		} catch {}
+		process.exit(0);
+	}
+	if (schema.overwrite) {
+		let confirm$1 = options.y || options.yes;
+		if (!confirm$1) confirm$1 = (await prompts({
+			type: "confirm",
+			name: "confirm",
+			message: `The file ${schema.fileName} already exists. Do you want to ${chalk.yellow(`${schema.overwrite ? "overwrite" : "append"}`)} the schema to the file?`
+		})).confirm;
+		if (confirm$1) {
+			if (!existsSync(path.join(cwd, schema.fileName))) await fs$1.mkdir(path.dirname(path.join(cwd, schema.fileName)), { recursive: true });
+			if (schema.overwrite) await fs$1.writeFile(path.join(cwd, schema.fileName), schema.code);
+			else await fs$1.appendFile(path.join(cwd, schema.fileName), schema.code);
+			console.log(`🚀 Schema was ${schema.overwrite ? "overwritten" : "appended"} successfully!`);
+			try {
+				await (await createTelemetry(config)).publish({
+					type: "cli_generate",
+					payload: {
+						outcome: schema.overwrite ? "overwritten" : "appended",
+						config: getTelemetryAuthConfig(config)
+					}
+				});
+			} catch {}
+			process.exit(0);
+		} else {
+			console.error("Schema generation aborted.");
+			try {
+				await (await createTelemetry(config)).publish({
+					type: "cli_generate",
+					payload: {
+						outcome: "aborted",
+						config: getTelemetryAuthConfig(config)
+					}
+				});
+			} catch {}
+			process.exit(1);
+		}
+	}
+	if (options.y) {
+		console.warn("WARNING: --y is deprecated. Consider -y or --yes");
+		options.yes = true;
+	}
+	let confirm = options.yes;
+	if (!confirm) confirm = (await prompts({
+		type: "confirm",
+		name: "confirm",
+		message: `Do you want to generate the schema to ${chalk.yellow(schema.fileName)}?`
+	})).confirm;
+	if (!confirm) {
+		console.error("Schema generation aborted.");
+		try {
+			await (await createTelemetry(config)).publish({
+				type: "cli_generate",
+				payload: {
+					outcome: "aborted",
+					config: getTelemetryAuthConfig(config)
+				}
+			});
+		} catch {}
+		process.exit(1);
+	}
+	if (!options.output) {
+		if (!existsSync(path.dirname(path.join(cwd, schema.fileName)))) await fs$1.mkdir(path.dirname(path.join(cwd, schema.fileName)), { recursive: true });
+	}
+	await fs$1.writeFile(options.output || path.join(cwd, schema.fileName), schema.code);
+	console.log(`🚀 Schema was generated successfully!`);
+	try {
+		await (await createTelemetry(config)).publish({
+			type: "cli_generate",
+			payload: {
+				outcome: "generated",
+				config: getTelemetryAuthConfig(config)
+			}
+		});
+	} catch {}
+	process.exit(0);
+}
+const generate = new Command("generate").option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).option("--config <config>", "the path to the configuration file. defaults to the first configuration file found.").option("--output <output>", "the file to output to the generated schema").option("-y, --yes", "automatically answer yes to all prompts", false).option("--y", "(deprecated) same as --yes", false).action(generateAction);
+
+//#endregion
+//#region src/commands/info.ts
+function getSystemInfo() {
+	const platform = os.platform();
+	const arch = os.arch();
+	const version = os.version();
+	const release = os.release();
+	const cpus = os.cpus();
+	const memory = os.totalmem();
+	const freeMemory = os.freemem();
+	return {
+		platform,
+		arch,
+		version,
+		release,
+		cpuCount: cpus.length,
+		cpuModel: cpus[0]?.model || "Unknown",
+		totalMemory: `${(memory / 1024 / 1024 / 1024).toFixed(2)} GB`,
+		freeMemory: `${(freeMemory / 1024 / 1024 / 1024).toFixed(2)} GB`
+	};
+}
+function getNodeInfo() {
+	return {
+		version: process.version,
+		env: process.env.NODE_ENV || "development"
+	};
+}
+function getPackageManager() {
+	const userAgent = process.env.npm_config_user_agent || "";
+	if (userAgent.includes("yarn")) return {
+		name: "yarn",
+		version: getVersion("yarn")
+	};
+	if (userAgent.includes("pnpm")) return {
+		name: "pnpm",
+		version: getVersion("pnpm")
+	};
+	if (userAgent.includes("bun")) return {
+		name: "bun",
+		version: getVersion("bun")
+	};
+	return {
+		name: "npm",
+		version: getVersion("npm")
+	};
+}
+function getVersion(command) {
+	try {
+		return execSync(`${command} --version`, { encoding: "utf8" }).trim();
+	} catch {
+		return "Not installed";
+	}
+}
+function getFrameworkInfo(projectRoot) {
+	const packageJsonPath = path.join(projectRoot, "package.json");
+	if (!existsSync(packageJsonPath)) return null;
+	try {
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+		const deps = {
+			...packageJson.dependencies,
+			...packageJson.devDependencies
+		};
+		const frameworks = {
+			next: deps["next"],
+			react: deps["react"],
+			vue: deps["vue"],
+			nuxt: deps["nuxt"],
+			svelte: deps["svelte"],
+			"@sveltejs/kit": deps["@sveltejs/kit"],
+			express: deps["express"],
+			fastify: deps["fastify"],
+			hono: deps["hono"],
+			remix: deps["@remix-run/react"],
+			astro: deps["astro"],
+			solid: deps["solid-js"],
+			qwik: deps["@builder.io/qwik"]
+		};
+		const installedFrameworks = Object.entries(frameworks).filter(([_, version]) => version).map(([name, version]) => ({
+			name,
+			version
+		}));
+		return installedFrameworks.length > 0 ? installedFrameworks : null;
+	} catch {
+		return null;
+	}
+}
+function getDatabaseInfo(projectRoot) {
+	const packageJsonPath = path.join(projectRoot, "package.json");
+	if (!existsSync(packageJsonPath)) return null;
+	try {
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+		const deps = {
+			...packageJson.dependencies,
+			...packageJson.devDependencies
+		};
+		const databases = {
+			"better-sqlite3": deps["better-sqlite3"],
+			"@libsql/client": deps["@libsql/client"],
+			"@libsql/kysely-libsql": deps["@libsql/kysely-libsql"],
+			mysql2: deps["mysql2"],
+			pg: deps["pg"],
+			postgres: deps["postgres"],
+			"@prisma/client": deps["@prisma/client"],
+			drizzle: deps["drizzle-orm"],
+			kysely: deps["kysely"],
+			mongodb: deps["mongodb"],
+			"@neondatabase/serverless": deps["@neondatabase/serverless"],
+			"@vercel/postgres": deps["@vercel/postgres"],
+			"@planetscale/database": deps["@planetscale/database"]
+		};
+		const installedDatabases = Object.entries(databases).filter(([_, version]) => version).map(([name, version]) => ({
+			name,
+			version
+		}));
+		return installedDatabases.length > 0 ? installedDatabases : null;
+	} catch {
+		return null;
+	}
+}
+function sanitizeBetterAuthConfig(config) {
+	if (!config) return null;
+	const sanitized = JSON.parse(JSON.stringify(config));
+	const sensitiveKeys = [
+		"secret",
+		"clientSecret",
+		"clientId",
+		"authToken",
+		"apiKey",
+		"apiSecret",
+		"privateKey",
+		"publicKey",
+		"password",
+		"token",
+		"webhook",
+		"connectionString",
+		"databaseUrl",
+		"databaseURL",
+		"TURSO_AUTH_TOKEN",
+		"TURSO_DATABASE_URL",
+		"MYSQL_DATABASE_URL",
+		"DATABASE_URL",
+		"POSTGRES_URL",
+		"MONGODB_URI",
+		"stripeKey",
+		"stripeWebhookSecret"
+	];
+	const allowedKeys = [
+		"baseURL",
+		"callbackURL",
+		"redirectURL",
+		"trustedOrigins",
+		"appName"
+	];
+	function redactSensitive(obj, parentKey) {
+		if (typeof obj !== "object" || obj === null) {
+			if (parentKey && typeof obj === "string" && obj.length > 0) {
+				if (allowedKeys.some((allowed) => parentKey.toLowerCase() === allowed.toLowerCase())) return obj;
+				const lowerKey = parentKey.toLowerCase();
+				if (sensitiveKeys.some((key) => {
+					const lowerSensitiveKey = key.toLowerCase();
+					return lowerKey === lowerSensitiveKey || lowerKey.endsWith(lowerSensitiveKey);
+				})) return "[REDACTED]";
+			}
+			return obj;
+		}
+		if (Array.isArray(obj)) return obj.map((item) => redactSensitive(item, parentKey));
+		const result = {};
+		for (const [key, value] of Object.entries(obj)) {
+			if (allowedKeys.some((allowed) => key.toLowerCase() === allowed.toLowerCase())) {
+				result[key] = value;
+				continue;
+			}
+			const lowerKey = key.toLowerCase();
+			if (sensitiveKeys.some((sensitiveKey) => {
+				const lowerSensitiveKey = sensitiveKey.toLowerCase();
+				return lowerKey === lowerSensitiveKey || lowerKey.endsWith(lowerSensitiveKey);
+			})) if (typeof value === "string" && value.length > 0) result[key] = "[REDACTED]";
+			else if (typeof value === "object" && value !== null) result[key] = redactSensitive(value, key);
+			else result[key] = value;
+			else result[key] = redactSensitive(value, key);
+		}
+		return result;
+	}
+	if (sanitized.database) {
+		if (typeof sanitized.database === "string") sanitized.database = "[REDACTED]";
+		else if (sanitized.database.url) sanitized.database.url = "[REDACTED]";
+		if (sanitized.database.authToken) sanitized.database.authToken = "[REDACTED]";
+	}
+	if (sanitized.socialProviders) {
+		for (const provider in sanitized.socialProviders) if (sanitized.socialProviders[provider]) sanitized.socialProviders[provider] = redactSensitive(sanitized.socialProviders[provider], provider);
+	}
+	if (sanitized.emailAndPassword?.sendResetPassword) sanitized.emailAndPassword.sendResetPassword = "[Function]";
+	if (sanitized.emailVerification?.sendVerificationEmail) sanitized.emailVerification.sendVerificationEmail = "[Function]";
+	if (sanitized.plugins && Array.isArray(sanitized.plugins)) sanitized.plugins = sanitized.plugins.map((plugin) => {
+		if (typeof plugin === "function") return "[Plugin Function]";
+		if (plugin && typeof plugin === "object") return {
+			name: plugin.id || plugin.name || "unknown",
+			config: redactSensitive(plugin.config || plugin)
+		};
+		return plugin;
+	});
+	return redactSensitive(sanitized);
+}
+async function getBetterAuthInfo(projectRoot, configPath, suppressLogs = false) {
+	try {
+		const originalLog = console.log;
+		const originalWarn = console.warn;
+		const originalError = console.error;
+		if (suppressLogs) {
+			console.log = () => {};
+			console.warn = () => {};
+			console.error = () => {};
+		}
+		try {
+			const config = await getConfig({
+				cwd: projectRoot,
+				configPath,
+				shouldThrowOnError: true
+			});
+			const packageInfo = await getPackageInfo();
+			return {
+				version: packageInfo.dependencies?.["better-auth"] || packageInfo.devDependencies?.["better-auth"] || packageInfo.peerDependencies?.["better-auth"] || packageInfo.optionalDependencies?.["better-auth"] || "Unknown",
+				config: sanitizeBetterAuthConfig(config)
+			};
+		} finally {
+			if (suppressLogs) {
+				console.log = originalLog;
+				console.warn = originalWarn;
+				console.error = originalError;
+			}
+		}
+	} catch (error) {
+		return {
+			version: "Unknown",
+			config: null,
+			error: error instanceof Error ? error.message : "Failed to load Better Auth config"
+		};
+	}
+}
+function formatOutput(data, indent = 0) {
+	const spaces = " ".repeat(indent);
+	if (data === null || data === void 0) return `${spaces}${chalk.gray("N/A")}`;
+	if (typeof data === "string" || typeof data === "number" || typeof data === "boolean") return `${spaces}${data}`;
+	if (Array.isArray(data)) {
+		if (data.length === 0) return `${spaces}${chalk.gray("[]")}`;
+		return data.map((item) => formatOutput(item, indent)).join("\n");
+	}
+	if (typeof data === "object") {
+		const entries = Object.entries(data);
+		if (entries.length === 0) return `${spaces}${chalk.gray("{}")}`;
+		return entries.map(([key, value]) => {
+			if (typeof value === "object" && value !== null && !Array.isArray(value)) return `${spaces}${chalk.cyan(key)}:\n${formatOutput(value, indent + 2)}`;
+			return `${spaces}${chalk.cyan(key)}: ${formatOutput(value, 0)}`;
+		}).join("\n");
+	}
+	return `${spaces}${JSON.stringify(data)}`;
+}
+const info = new Command("info").description("Display system and Better Auth configuration information").option("--cwd <cwd>", "The working directory", process.cwd()).option("--config <config>", "Path to the Better Auth configuration file").option("-j, --json", "Output as JSON").option("-c, --copy", "Copy output to clipboard (requires pbcopy/xclip)").action(async (options) => {
+	const projectRoot = path.resolve(options.cwd || process.cwd());
+	const systemInfo = getSystemInfo();
+	const nodeInfo = getNodeInfo();
+	const packageManager = getPackageManager();
+	const frameworks = getFrameworkInfo(projectRoot);
+	const databases = getDatabaseInfo(projectRoot);
+	const betterAuthInfo = await getBetterAuthInfo(projectRoot, options.config, options.json);
+	const fullInfo = {
+		system: systemInfo,
+		node: nodeInfo,
+		packageManager,
+		frameworks,
+		databases,
+		betterAuth: betterAuthInfo
+	};
+	if (options.json) {
+		const jsonOutput = JSON.stringify(fullInfo, null, 2);
+		console.log(jsonOutput);
+		if (options.copy) try {
+			const platform = os.platform();
+			if (platform === "darwin") {
+				execSync("pbcopy", { input: jsonOutput });
+				console.log(chalk.green("\n✓ Copied to clipboard"));
+			} else if (platform === "linux") {
+				execSync("xclip -selection clipboard", { input: jsonOutput });
+				console.log(chalk.green("\n✓ Copied to clipboard"));
+			} else if (platform === "win32") {
+				execSync("clip", { input: jsonOutput });
+				console.log(chalk.green("\n✓ Copied to clipboard"));
+			}
+		} catch {
+			console.log(chalk.yellow("\n⚠ Could not copy to clipboard"));
+		}
+		return;
+	}
+	console.log(chalk.bold("\n📊 Better Auth System Information\n"));
+	console.log(chalk.gray("=".repeat(50)));
+	console.log(chalk.bold.white("\n🖥️  System Information:"));
+	console.log(formatOutput(systemInfo, 2));
+	console.log(chalk.bold.white("\n📦 Node.js:"));
+	console.log(formatOutput(nodeInfo, 2));
+	console.log(chalk.bold.white("\n📦 Package Manager:"));
+	console.log(formatOutput(packageManager, 2));
+	if (frameworks) {
+		console.log(chalk.bold.white("\n🚀 Frameworks:"));
+		console.log(formatOutput(frameworks, 2));
+	}
+	if (databases) {
+		console.log(chalk.bold.white("\n💾 Database Clients:"));
+		console.log(formatOutput(databases, 2));
+	}
+	console.log(chalk.bold.white("\n🔐 Better Auth:"));
+	if (betterAuthInfo.error) console.log(`  ${chalk.red("Error:")} ${betterAuthInfo.error}`);
+	else {
+		console.log(`  ${chalk.cyan("Version")}: ${betterAuthInfo.version}`);
+		if (betterAuthInfo.config) {
+			console.log(`  ${chalk.cyan("Configuration")}:`);
+			console.log(formatOutput(betterAuthInfo.config, 4));
+		}
+	}
+	console.log(chalk.gray("\n" + "=".repeat(50)));
+	console.log(chalk.gray("\n💡 Tip: Use --json flag for JSON output"));
+	console.log(chalk.gray("💡 Use --copy flag to copy output to clipboard"));
+	console.log(chalk.gray("💡 When reporting issues, include this information\n"));
+	if (options.copy) {
+		const textOutput = `
+Better Auth System Information
+==============================
+
+System Information:
+${JSON.stringify(systemInfo, null, 2)}
+
+Node.js:
+${JSON.stringify(nodeInfo, null, 2)}
+
+Package Manager:
+${JSON.stringify(packageManager, null, 2)}
+
+Frameworks:
+${JSON.stringify(frameworks, null, 2)}
+
+Database Clients:
+${JSON.stringify(databases, null, 2)}
+
+Better Auth:
+${JSON.stringify(betterAuthInfo, null, 2)}
+`;
+		try {
+			const platform = os.platform();
+			if (platform === "darwin") {
+				execSync("pbcopy", { input: textOutput });
+				console.log(chalk.green("✓ Copied to clipboard"));
+			} else if (platform === "linux") {
+				execSync("xclip -selection clipboard", { input: textOutput });
+				console.log(chalk.green("✓ Copied to clipboard"));
+			} else if (platform === "win32") {
+				execSync("clip", { input: textOutput });
+				console.log(chalk.green("✓ Copied to clipboard"));
+			}
+		} catch {
+			console.log(chalk.yellow("⚠ Could not copy to clipboard"));
+		}
+	}
+});
+
+//#endregion
+//#region src/commands/init.ts
+const init = new Command("init").option("-c, --cwd <cwd>", "The working directory.", process.cwd()).option("--config <config>", "The path to the auth configuration file. defaults to the first `auth.ts` file found.").option("--tsconfig <tsconfig>", "The path to the tsconfig file.").option("--skip-db", "Skip the database setup.").option("--skip-plugins", "Skip the plugins setup.").option("--package-manager <package-manager>", "The package manager you want to use.").action();
+
+//#endregion
+//#region src/commands/migrate.ts
+/** @internal */
+async function migrateAction(opts) {
+	const options = z.object({
+		cwd: z.string(),
+		config: z.string().optional(),
+		y: z.boolean().optional(),
+		yes: z.boolean().optional()
+	}).parse(opts);
+	const cwd = path.resolve(options.cwd);
+	if (!existsSync(cwd)) {
+		console.error(`The directory "${cwd}" does not exist.`);
+		process.exit(1);
+	}
+	const config = await getConfig({
+		cwd,
+		configPath: options.config
+	});
+	if (!config) {
+		console.error("No configuration file found. Add a `auth.ts` file to your project or pass the path to the configuration file using the `--config` flag.");
+		return;
+	}
+	const db = await getAdapter(config);
+	if (!db) {
+		console.error("Invalid database configuration. Make sure you're not using adapters. Migrate command only works with built-in Kysely adapter.");
+		process.exit(1);
+	}
+	if (db.id !== "kysely") {
+		if (db.id === "prisma") console.error("The migrate command only works with the built-in Kysely adapter. For Prisma, run `npx @better-auth/cli generate` to create the schema, then use Prisma's migrate or push to apply it.");
+		if (db.id === "drizzle") console.error("The migrate command only works with the built-in Kysely adapter. For Drizzle, run `npx @better-auth/cli generate` to create the schema, then use Drizzle's migrate or push to apply it.");
+		console.error("Migrate command isn't supported for this adapter.");
+	}
+	const spinner = yoctoSpinner({ text: "preparing migration..." }).start();
+	const { toBeAdded, toBeCreated, runMigrations } = await getMigrations(config);
+	spinner.stop();
+	console.log(`🔑 The migration will affect the following:`);
+	for (const table of [...toBeCreated, ...toBeAdded]) console.log("->", chalk.magenta(Object.keys(table.fields).join(", ")), chalk.white("fields on"), chalk.yellow(`${table.table}`), chalk.white("table."));
+	if (options.y) {
+		console.warn("WARNING: --y is deprecated. Consider -y or --yes");
+		options.yes = true;
+	}
+	let migrate$1 = options.yes;
+	if (!migrate$1) migrate$1 = (await prompts({
+		type: "confirm",
+		name: "migrate",
+		message: "Are you sure you want to run these migrations?",
+		initial: false
+	})).migrate;
+	spinner?.start("migrating...");
+	await runMigrations();
+	spinner.stop();
+	console.log("🚀 migration was completed successfully!");
+}
+const migrate = new Command("migrate").option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).option("--config <config>", "the path to the configuration file. defaults to the first configuration file found.").option("-y, --yes", "automatically accept and run migrations without prompting", false).option("--y", "(deprecated) same as --yes", false).action(migrateAction);
+
+//#endregion
+//#region src/index.ts
+process.on("SIGINT", () => process.exit(0));
+process.on("SIGTERM", () => process.exit(0));
+async function main() {
+	const program = new Command("better-auth");
+	let packageInfo = {};
+	try {
+		packageInfo = await getPackageInfo();
+	} catch {}
+	program.addCommand(init).addCommand(migrate).addCommand(generate).addCommand(info).version(packageInfo.version || "0.0.0").description("Pecunia CLI").action(() => program.help());
+	program.parse();
+}
+main().catch((error) => {
+	console.error("Error running Pecunia CLI:", error);
+	process.exit(1);
+});
+
+//#endregion
+export {  };