@pleaseai/agent 0.1.16 → 0.1.17

package/.output/server/node_modules/better-auth/dist/db/schema.mjs

@@ -0,0 +1,127 @@
+import { getAuthTables } from "@better-auth/core/db";
+import { APIError, BASE_ERROR_CODES } from "@better-auth/core/error";
+import { filterOutputFields } from "@better-auth/core/utils/db";
+
+//#region src/db/schema.ts
+const cache = /* @__PURE__ */ new WeakMap();
+function getFields(options, modelName, mode) {
+	const cacheKey = `${modelName}:${mode}`;
+	if (!cache.has(options)) cache.set(options, /* @__PURE__ */ new Map());
+	const tableCache = cache.get(options);
+	if (tableCache.has(cacheKey)) return tableCache.get(cacheKey);
+	const coreSchema = mode === "output" ? getAuthTables(options)[modelName]?.fields ?? {} : {};
+	const additionalFields = modelName === "user" || modelName === "session" || modelName === "account" ? options[modelName]?.additionalFields : void 0;
+	let schema = {
+		...coreSchema,
+		...additionalFields ?? {}
+	};
+	for (const plugin of options.plugins || []) if (plugin.schema && plugin.schema[modelName]) schema = {
+		...schema,
+		...plugin.schema[modelName].fields
+	};
+	tableCache.set(cacheKey, schema);
+	return schema;
+}
+function parseUserOutput(options, user) {
+	return filterOutputFields(user, getFields(options, "user", "output"));
+}
+function parseSessionOutput(options, session) {
+	return filterOutputFields(session, getFields(options, "session", "output"));
+}
+function parseAccountOutput(options, account) {
+	const { accessToken: _accessToken, refreshToken: _refreshToken, idToken: _idToken, accessTokenExpiresAt: _accessTokenExpiresAt, refreshTokenExpiresAt: _refreshTokenExpiresAt, password: _password, ...rest } = filterOutputFields(account, getFields(options, "account", "output"));
+	return rest;
+}
+function parseInputData(data, schema) {
+	const action = schema.action || "create";
+	const fields = schema.fields;
+	const parsedData = Object.create(null);
+	for (const key in fields) {
+		if (key in data) {
+			if (fields[key].input === false) {
+				if (fields[key].defaultValue !== void 0) {
+					if (action !== "update") {
+						parsedData[key] = fields[key].defaultValue;
+						continue;
+					}
+				}
+				if (data[key]) throw APIError.from("BAD_REQUEST", {
+					...BASE_ERROR_CODES.FIELD_NOT_ALLOWED,
+					message: `${key} is not allowed to be set`
+				});
+				continue;
+			}
+			if (fields[key].validator?.input && data[key] !== void 0) {
+				const result = fields[key].validator.input["~standard"].validate(data[key]);
+				if (result instanceof Promise) throw APIError.from("INTERNAL_SERVER_ERROR", BASE_ERROR_CODES.ASYNC_VALIDATION_NOT_SUPPORTED);
+				if ("issues" in result && result.issues) throw APIError.from("BAD_REQUEST", {
+					...BASE_ERROR_CODES.VALIDATION_ERROR,
+					message: result.issues[0]?.message || "Validation Error"
+				});
+				parsedData[key] = result.value;
+				continue;
+			}
+			if (fields[key].transform?.input && data[key] !== void 0) {
+				parsedData[key] = fields[key].transform?.input(data[key]);
+				continue;
+			}
+			parsedData[key] = data[key];
+			continue;
+		}
+		if (fields[key].defaultValue !== void 0 && action === "create") {
+			if (typeof fields[key].defaultValue === "function") {
+				parsedData[key] = fields[key].defaultValue();
+				continue;
+			}
+			parsedData[key] = fields[key].defaultValue;
+			continue;
+		}
+		if (fields[key].required && action === "create") throw APIError.from("BAD_REQUEST", {
+			...BASE_ERROR_CODES.MISSING_FIELD,
+			message: `${key} is required`
+		});
+	}
+	return parsedData;
+}
+function parseUserInput(options, user = {}, action) {
+	return parseInputData(user, {
+		fields: getFields(options, "user", "input"),
+		action
+	});
+}
+function parseAdditionalUserInput(options, user) {
+	const schema = getFields(options, "user", "input");
+	return parseInputData(user || {}, { fields: schema });
+}
+function parseAccountInput(options, account) {
+	return parseInputData(account, { fields: getFields(options, "account", "input") });
+}
+function parseSessionInput(options, session, action) {
+	return parseInputData(session, {
+		fields: getFields(options, "session", "input"),
+		action
+	});
+}
+function getSessionDefaultFields(options) {
+	const fields = getFields(options, "session", "input");
+	const defaults = {};
+	for (const key in fields) if (fields[key].defaultValue !== void 0) defaults[key] = typeof fields[key].defaultValue === "function" ? fields[key].defaultValue() : fields[key].defaultValue;
+	return defaults;
+}
+function mergeSchema(schema, newSchema) {
+	if (!newSchema) return schema;
+	for (const table in newSchema) {
+		const newModelName = newSchema[table]?.modelName;
+		if (newModelName) schema[table].modelName = newModelName;
+		for (const field in schema[table].fields) {
+			const newField = newSchema[table]?.fields?.[field];
+			if (!newField) continue;
+			schema[table].fields[field].fieldName = newField;
+		}
+	}
+	return schema;
+}
+
+//#endregion
+export { getSessionDefaultFields, mergeSchema, parseAccountInput, parseAccountOutput, parseAdditionalUserInput, parseInputData, parseSessionInput, parseSessionOutput, parseUserInput, parseUserOutput };
+//# sourceMappingURL=schema.mjs.map

package/.output/server/node_modules/better-auth/dist/db/to-zod.mjs

@@ -0,0 +1,26 @@
+import * as z from "zod";
+
+//#region src/db/to-zod.ts
+function toZodSchema({ fields, isClientSide }) {
+	const zodFields = Object.keys(fields).reduce((acc, key) => {
+		const field = fields[key];
+		if (!field) return acc;
+		if (isClientSide && field.input === false) return acc;
+		let schema;
+		if (field.type === "json") schema = z.json ? z.json() : z.any();
+		else if (field.type === "string[]" || field.type === "number[]") schema = z.array(field.type === "string[]" ? z.string() : z.number());
+		else if (Array.isArray(field.type)) schema = z.any();
+		else schema = z[field.type]();
+		if (field?.required === false) schema = schema.optional();
+		if (!isClientSide && field?.returned === false) return acc;
+		return {
+			...acc,
+			[key]: schema
+		};
+	}, {});
+	return z.object(zodFields);
+}
+
+//#endregion
+export { toZodSchema };
+//# sourceMappingURL=to-zod.mjs.map

package/.output/server/node_modules/better-auth/dist/db/verification-token-storage.mjs

@@ -0,0 +1,28 @@
+import { base64Url } from "@better-auth/utils/base64";
+import { createHash } from "@better-auth/utils/hash";
+
+//#region src/db/verification-token-storage.ts
+const defaultKeyHasher = async (identifier) => {
+	const hash = await createHash("SHA-256").digest(new TextEncoder().encode(identifier));
+	return base64Url.encode(new Uint8Array(hash), { padding: false });
+};
+async function processIdentifier(identifier, option) {
+	if (!option || option === "plain") return identifier;
+	if (option === "hashed") return defaultKeyHasher(identifier);
+	if (typeof option === "object" && "hash" in option) return option.hash(identifier);
+	return identifier;
+}
+function getStorageOption(identifier, config) {
+	if (!config) return;
+	if (typeof config === "object" && "default" in config) {
+		if (config.overrides) {
+			for (const [prefix, option] of Object.entries(config.overrides)) if (identifier.startsWith(prefix)) return option;
+		}
+		return config.default;
+	}
+	return config;
+}
+
+//#endregion
+export { getStorageOption, processIdentifier };
+//# sourceMappingURL=verification-token-storage.mjs.map

package/.output/server/node_modules/better-auth/dist/db/with-hooks.mjs

@@ -0,0 +1,159 @@
+import { getCurrentAdapter, getCurrentAuthContext, queueAfterTransactionHook } from "@better-auth/core/context";
+
+//#region src/db/with-hooks.ts
+function getWithHooks(adapter, ctx) {
+	const hooks = ctx.hooks;
+	async function createWithHooks(data, model, customCreateFn) {
+		const context = await getCurrentAuthContext().catch(() => null);
+		let actualData = data;
+		for (const hook of hooks || []) {
+			const toRun = hook[model]?.create?.before;
+			if (toRun) {
+				const result = await toRun(actualData, context);
+				if (result === false) return null;
+				if (typeof result === "object" && "data" in result) actualData = {
+					...actualData,
+					...result.data
+				};
+			}
+		}
+		let created = null;
+		if (!customCreateFn || customCreateFn.executeMainFn) created = await (await getCurrentAdapter(adapter)).create({
+			model,
+			data: actualData,
+			forceAllowId: true
+		});
+		if (customCreateFn?.fn) created = await customCreateFn.fn(created ?? actualData);
+		for (const hook of hooks || []) {
+			const toRun = hook[model]?.create?.after;
+			if (toRun) await queueAfterTransactionHook(async () => {
+				await toRun(created, context);
+			});
+		}
+		return created;
+	}
+	async function updateWithHooks(data, where, model, customUpdateFn) {
+		const context = await getCurrentAuthContext().catch(() => null);
+		let actualData = data;
+		for (const hook of hooks || []) {
+			const toRun = hook[model]?.update?.before;
+			if (toRun) {
+				const result = await toRun(data, context);
+				if (result === false) return null;
+				if (typeof result === "object" && "data" in result) actualData = {
+					...actualData,
+					...result.data
+				};
+			}
+		}
+		const customUpdated = customUpdateFn ? await customUpdateFn.fn(actualData) : null;
+		const updated = !customUpdateFn || customUpdateFn.executeMainFn ? await (await getCurrentAdapter(adapter)).update({
+			model,
+			update: actualData,
+			where
+		}) : customUpdated;
+		for (const hook of hooks || []) {
+			const toRun = hook[model]?.update?.after;
+			if (toRun) await queueAfterTransactionHook(async () => {
+				await toRun(updated, context);
+			});
+		}
+		return updated;
+	}
+	async function updateManyWithHooks(data, where, model, customUpdateFn) {
+		const context = await getCurrentAuthContext().catch(() => null);
+		let actualData = data;
+		for (const hook of hooks || []) {
+			const toRun = hook[model]?.update?.before;
+			if (toRun) {
+				const result = await toRun(data, context);
+				if (result === false) return null;
+				if (typeof result === "object" && "data" in result) actualData = {
+					...actualData,
+					...result.data
+				};
+			}
+		}
+		const customUpdated = customUpdateFn ? await customUpdateFn.fn(actualData) : null;
+		const updated = !customUpdateFn || customUpdateFn.executeMainFn ? await (await getCurrentAdapter(adapter)).updateMany({
+			model,
+			update: actualData,
+			where
+		}) : customUpdated;
+		for (const hook of hooks || []) {
+			const toRun = hook[model]?.update?.after;
+			if (toRun) await queueAfterTransactionHook(async () => {
+				await toRun(updated, context);
+			});
+		}
+		return updated;
+	}
+	async function deleteWithHooks(where, model, customDeleteFn) {
+		const context = await getCurrentAuthContext().catch(() => null);
+		let entityToDelete = null;
+		try {
+			entityToDelete = (await (await getCurrentAdapter(adapter)).findMany({
+				model,
+				where,
+				limit: 1
+			}))[0] || null;
+		} catch {}
+		if (entityToDelete) for (const hook of hooks || []) {
+			const toRun = hook[model]?.delete?.before;
+			if (toRun) {
+				if (await toRun(entityToDelete, context) === false) return null;
+			}
+		}
+		const customDeleted = customDeleteFn ? await customDeleteFn.fn(where) : null;
+		const deleted = (!customDeleteFn || customDeleteFn.executeMainFn) && entityToDelete ? await (await getCurrentAdapter(adapter)).delete({
+			model,
+			where
+		}) : customDeleted;
+		if (entityToDelete) for (const hook of hooks || []) {
+			const toRun = hook[model]?.delete?.after;
+			if (toRun) await queueAfterTransactionHook(async () => {
+				await toRun(entityToDelete, context);
+			});
+		}
+		return deleted;
+	}
+	async function deleteManyWithHooks(where, model, customDeleteFn) {
+		const context = await getCurrentAuthContext().catch(() => null);
+		let entitiesToDelete = [];
+		try {
+			entitiesToDelete = await (await getCurrentAdapter(adapter)).findMany({
+				model,
+				where
+			});
+		} catch {}
+		for (const entity of entitiesToDelete) for (const hook of hooks || []) {
+			const toRun = hook[model]?.delete?.before;
+			if (toRun) {
+				if (await toRun(entity, context) === false) return null;
+			}
+		}
+		const customDeleted = customDeleteFn ? await customDeleteFn.fn(where) : null;
+		const deleted = !customDeleteFn || customDeleteFn.executeMainFn ? await (await getCurrentAdapter(adapter)).deleteMany({
+			model,
+			where
+		}) : customDeleted;
+		for (const entity of entitiesToDelete) for (const hook of hooks || []) {
+			const toRun = hook[model]?.delete?.after;
+			if (toRun) await queueAfterTransactionHook(async () => {
+				await toRun(entity, context);
+			});
+		}
+		return deleted;
+	}
+	return {
+		createWithHooks,
+		updateWithHooks,
+		updateManyWithHooks,
+		deleteWithHooks,
+		deleteManyWithHooks
+	};
+}
+
+//#endregion
+export { getWithHooks };
+//# sourceMappingURL=with-hooks.mjs.map

package/.output/server/node_modules/better-auth/dist/index.mjs

@@ -0,0 +1,27 @@
+import { getBaseURL, getHost, getHostFromRequest, getOrigin, getProtocol, getProtocolFromRequest, isDynamicBaseURLConfig, matchesHostPattern, resolveBaseURL, resolveDynamicBaseURL } from "./utils/url.mjs";
+import { generateGenericState, parseGenericState } from "./state.mjs";
+import { generateState, parseState } from "./oauth2/state.mjs";
+import { HIDE_METADATA } from "./utils/hide-metadata.mjs";
+import "./utils/index.mjs";
+import { APIError } from "./api/index.mjs";
+import { betterAuth } from "./auth/full.mjs";
+import { getCurrentAdapter } from "@better-auth/core/context";
+import { createTelemetry, getTelemetryAuthConfig } from "@better-auth/telemetry";
+
+export * from "@better-auth/core"
+
+export * from "@better-auth/core/db"
+
+export * from "@better-auth/core/env"
+
+export * from "@better-auth/core/error"
+
+export * from "@better-auth/core/oauth2"
+
+export * from "@better-auth/core/utils/error-codes"
+
+export * from "@better-auth/core/utils/id"
+
+export * from "@better-auth/core/utils/json"
+
+export { APIError, HIDE_METADATA, betterAuth, createTelemetry, generateGenericState, generateState, getBaseURL, getCurrentAdapter, getHost, getHostFromRequest, getOrigin, getProtocol, getProtocolFromRequest, getTelemetryAuthConfig, isDynamicBaseURLConfig, matchesHostPattern, parseGenericState, parseState, resolveBaseURL, resolveDynamicBaseURL };

package/.output/server/node_modules/better-auth/dist/oauth2/link-account.mjs

@@ -0,0 +1,143 @@
+import { isAPIError } from "../utils/is-api-error.mjs";
+import { setAccountCookie } from "../cookies/session-store.mjs";
+import { setTokenUtil } from "./utils.mjs";
+import { createEmailVerificationToken } from "../api/routes/email-verification.mjs";
+import "../api/index.mjs";
+import { isDevelopment, logger } from "@better-auth/core/env";
+
+//#region src/oauth2/link-account.ts
+async function handleOAuthUserInfo(c, opts) {
+	const { userInfo, account, callbackURL, disableSignUp, overrideUserInfo } = opts;
+	const dbUser = await c.context.internalAdapter.findOAuthUser(userInfo.email.toLowerCase(), account.accountId, account.providerId).catch((e) => {
+		logger.error("Better auth was unable to query your database.\nError: ", e);
+		const errorURL = c.context.options.onAPIError?.errorURL || `${c.context.baseURL}/error`;
+		throw c.redirect(`${errorURL}?error=internal_server_error`);
+	});
+	let user = dbUser?.user;
+	const isRegister = !user;
+	if (dbUser) {
+		const linkedAccount = dbUser.linkedAccount ?? dbUser.accounts.find((acc) => acc.providerId === account.providerId && acc.accountId === account.accountId);
+		if (!linkedAccount) {
+			const accountLinking = c.context.options.account?.accountLinking;
+			if (!(opts.isTrustedProvider || c.context.trustedProviders.includes(account.providerId)) && !userInfo.emailVerified || accountLinking?.enabled === false || accountLinking?.disableImplicitLinking === true) {
+				if (isDevelopment()) logger.warn(`User already exist but account isn't linked to ${account.providerId}. To read more about how account linking works in Better Auth see https://www.better-auth.com/docs/concepts/users-accounts#account-linking.`);
+				return {
+					error: "account not linked",
+					data: null
+				};
+			}
+			try {
+				await c.context.internalAdapter.linkAccount({
+					providerId: account.providerId,
+					accountId: userInfo.id.toString(),
+					userId: dbUser.user.id,
+					accessToken: await setTokenUtil(account.accessToken, c.context),
+					refreshToken: await setTokenUtil(account.refreshToken, c.context),
+					idToken: account.idToken,
+					accessTokenExpiresAt: account.accessTokenExpiresAt,
+					refreshTokenExpiresAt: account.refreshTokenExpiresAt,
+					scope: account.scope
+				});
+			} catch (e) {
+				logger.error("Unable to link account", e);
+				return {
+					error: "unable to link account",
+					data: null
+				};
+			}
+			if (userInfo.emailVerified && !dbUser.user.emailVerified && userInfo.email.toLowerCase() === dbUser.user.email) await c.context.internalAdapter.updateUser(dbUser.user.id, { emailVerified: true });
+		} else {
+			const freshTokens = c.context.options.account?.updateAccountOnSignIn !== false ? Object.fromEntries(Object.entries({
+				idToken: account.idToken,
+				accessToken: await setTokenUtil(account.accessToken, c.context),
+				refreshToken: await setTokenUtil(account.refreshToken, c.context),
+				accessTokenExpiresAt: account.accessTokenExpiresAt,
+				refreshTokenExpiresAt: account.refreshTokenExpiresAt,
+				scope: account.scope
+			}).filter(([_, value]) => value !== void 0)) : {};
+			if (c.context.options.account?.storeAccountCookie) await setAccountCookie(c, {
+				...linkedAccount,
+				...freshTokens
+			});
+			if (Object.keys(freshTokens).length > 0) await c.context.internalAdapter.updateAccount(linkedAccount.id, freshTokens);
+			if (userInfo.emailVerified && !dbUser.user.emailVerified && userInfo.email.toLowerCase() === dbUser.user.email) await c.context.internalAdapter.updateUser(dbUser.user.id, { emailVerified: true });
+		}
+		if (overrideUserInfo) {
+			const { id: _, ...restUserInfo } = userInfo;
+			user = await c.context.internalAdapter.updateUser(dbUser.user.id, {
+				...restUserInfo,
+				email: userInfo.email.toLowerCase(),
+				emailVerified: userInfo.email.toLowerCase() === dbUser.user.email ? dbUser.user.emailVerified || userInfo.emailVerified : userInfo.emailVerified
+			});
+		}
+	} else {
+		if (disableSignUp) return {
+			error: "signup disabled",
+			data: null,
+			isRegister: false
+		};
+		try {
+			const { id: _, ...restUserInfo } = userInfo;
+			const accountData = {
+				accessToken: await setTokenUtil(account.accessToken, c.context),
+				refreshToken: await setTokenUtil(account.refreshToken, c.context),
+				idToken: account.idToken,
+				accessTokenExpiresAt: account.accessTokenExpiresAt,
+				refreshTokenExpiresAt: account.refreshTokenExpiresAt,
+				scope: account.scope,
+				providerId: account.providerId,
+				accountId: userInfo.id.toString()
+			};
+			const { user: createdUser, account: createdAccount } = await c.context.internalAdapter.createOAuthUser({
+				...restUserInfo,
+				email: userInfo.email.toLowerCase()
+			}, accountData);
+			user = createdUser;
+			if (c.context.options.account?.storeAccountCookie) await setAccountCookie(c, createdAccount);
+			if (!userInfo.emailVerified && user && c.context.options.emailVerification?.sendOnSignUp && c.context.options.emailVerification?.sendVerificationEmail) {
+				const token = await createEmailVerificationToken(c.context.secret, user.email, void 0, c.context.options.emailVerification?.expiresIn);
+				const url = `${c.context.baseURL}/verify-email?token=${token}&callbackURL=${callbackURL}`;
+				await c.context.runInBackgroundOrAwait(c.context.options.emailVerification.sendVerificationEmail({
+					user,
+					url,
+					token
+				}, c.request));
+			}
+		} catch (e) {
+			logger.error(e);
+			if (isAPIError(e)) return {
+				error: e.message,
+				data: null,
+				isRegister: false
+			};
+			return {
+				error: "unable to create user",
+				data: null,
+				isRegister: false
+			};
+		}
+	}
+	if (!user) return {
+		error: "unable to create user",
+		data: null,
+		isRegister: false
+	};
+	const session = await c.context.internalAdapter.createSession(user.id);
+	if (!session) return {
+		error: "unable to create session",
+		data: null,
+		isRegister: false
+	};
+	return {
+		data: {
+			session,
+			user
+		},
+		error: null,
+		isRegister
+	};
+}
+
+//#endregion
+export { handleOAuthUserInfo };
+//# sourceMappingURL=link-account.mjs.map

package/.output/server/node_modules/better-auth/dist/oauth2/state.mjs

@@ -0,0 +1,51 @@
+import { generateRandomString } from "../crypto/random.mjs";
+import "../crypto/index.mjs";
+import { setOAuthState } from "../api/state/oauth.mjs";
+import { StateError, generateGenericState, parseGenericState } from "../state.mjs";
+import { APIError, BASE_ERROR_CODES } from "@better-auth/core/error";
+
+//#region src/oauth2/state.ts
+async function generateState(c, link, additionalData) {
+	const callbackURL = c.body?.callbackURL || c.context.options.baseURL;
+	if (!callbackURL) throw APIError.from("BAD_REQUEST", BASE_ERROR_CODES.CALLBACK_URL_REQUIRED);
+	const codeVerifier = generateRandomString(128);
+	const stateData = {
+		...additionalData ? additionalData : {},
+		callbackURL,
+		codeVerifier,
+		errorURL: c.body?.errorCallbackURL,
+		newUserURL: c.body?.newUserCallbackURL,
+		link,
+		expiresAt: Date.now() + 600 * 1e3,
+		requestSignUp: c.body?.requestSignUp
+	};
+	await setOAuthState(stateData);
+	try {
+		return generateGenericState(c, stateData);
+	} catch (error) {
+		c.context.logger.error("Failed to create verification", error);
+		throw new APIError("INTERNAL_SERVER_ERROR", {
+			message: "Unable to create verification",
+			cause: error
+		});
+	}
+}
+async function parseState(c) {
+	const state = c.query.state || c.body.state;
+	const errorURL = c.context.options.onAPIError?.errorURL || `${c.context.baseURL}/error`;
+	let parsedData;
+	try {
+		parsedData = await parseGenericState(c, state);
+	} catch (error) {
+		c.context.logger.error("Failed to parse state", error);
+		if (error instanceof StateError && error.code === "state_security_mismatch") throw c.redirect(`${errorURL}?error=state_mismatch`);
+		throw c.redirect(`${errorURL}?error=please_restart_the_process`);
+	}
+	if (!parsedData.errorURL) parsedData.errorURL = errorURL;
+	if (parsedData) await setOAuthState(parsedData);
+	return parsedData;
+}
+
+//#endregion
+export { generateState, parseState };
+//# sourceMappingURL=state.mjs.map

package/.output/server/node_modules/better-auth/dist/oauth2/utils.mjs

@@ -0,0 +1,32 @@
+import { symmetricDecrypt, symmetricEncrypt } from "../crypto/index.mjs";
+
+//#region src/oauth2/utils.ts
+/**
+* Check if a string looks like encrypted data
+*/
+function isLikelyEncrypted(token) {
+	if (token.startsWith("$ba$")) return true;
+	return token.length % 2 === 0 && /^[0-9a-f]+$/i.test(token);
+}
+function decryptOAuthToken(token, ctx) {
+	if (!token) return token;
+	if (ctx.options.account?.encryptOAuthTokens) {
+		if (!isLikelyEncrypted(token)) return token;
+		return symmetricDecrypt({
+			key: ctx.secretConfig,
+			data: token
+		});
+	}
+	return token;
+}
+function setTokenUtil(token, ctx) {
+	if (ctx.options.account?.encryptOAuthTokens && token) return symmetricEncrypt({
+		key: ctx.secretConfig,
+		data: token
+	});
+	return token;
+}
+
+//#endregion
+export { decryptOAuthToken, setTokenUtil };
+//# sourceMappingURL=utils.mjs.map

package/.output/server/node_modules/better-auth/dist/plugins/access/access.mjs

@@ -0,0 +1,46 @@
+import { BetterAuthError } from "@better-auth/core/error";
+
+//#region src/plugins/access/access.ts
+function role(statements) {
+	return {
+		authorize(request, connector = "AND") {
+			let success = false;
+			for (const [requestedResource, requestedActions] of Object.entries(request)) {
+				const allowedActions = statements[requestedResource];
+				if (!allowedActions) return {
+					success: false,
+					error: `You are not allowed to access resource: ${requestedResource}`
+				};
+				if (Array.isArray(requestedActions)) success = requestedActions.every((requestedAction) => allowedActions.includes(requestedAction));
+				else if (typeof requestedActions === "object") {
+					const actions = requestedActions;
+					if (actions.connector === "OR") success = actions.actions.some((requestedAction) => allowedActions.includes(requestedAction));
+					else success = actions.actions.every((requestedAction) => allowedActions.includes(requestedAction));
+				} else throw new BetterAuthError("Invalid access control request");
+				if (success && connector === "OR") return { success };
+				if (!success && connector === "AND") return {
+					success: false,
+					error: `unauthorized to access resource "${requestedResource}"`
+				};
+			}
+			if (success) return { success };
+			return {
+				success: false,
+				error: "Not authorized"
+			};
+		},
+		statements
+	};
+}
+function createAccessControl(s) {
+	return {
+		newRole(statements) {
+			return role(statements);
+		},
+		statements: s
+	};
+}
+
+//#endregion
+export { createAccessControl, role };
+//# sourceMappingURL=access.mjs.map

package/.output/server/node_modules/better-auth/dist/plugins/access/index.mjs

@@ -0,0 +1,3 @@
+import { createAccessControl, role } from "./access.mjs";
+
+export { createAccessControl, role };

package/.output/server/node_modules/better-auth/dist/plugins/additional-fields/client.mjs

@@ -0,0 +1,11 @@
+//#region src/plugins/additional-fields/client.ts
+const inferAdditionalFields = (schema) => {
+	return {
+		id: "additional-fields-client",
+		$InferServerPlugin: {}
+	};
+};
+
+//#endregion
+export { inferAdditionalFields };
+//# sourceMappingURL=client.mjs.map

package/.output/server/node_modules/better-auth/dist/plugins/admin/access/index.mjs

@@ -0,0 +1,3 @@
+import { adminAc, defaultAc, defaultRoles, defaultStatements, userAc } from "./statement.mjs";
+
+export { adminAc, defaultAc, defaultRoles, defaultStatements, userAc };