@pleaseai/agent 0.1.16 → 0.1.17

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

@@ -0,0 +1,34 @@
+//#region src/plugins/admin/schema.ts
+const schema = {
+	user: { fields: {
+		role: {
+			type: "string",
+			required: false,
+			input: false
+		},
+		banned: {
+			type: "boolean",
+			defaultValue: false,
+			required: false,
+			input: false
+		},
+		banReason: {
+			type: "string",
+			required: false,
+			input: false
+		},
+		banExpires: {
+			type: "date",
+			required: false,
+			input: false
+		}
+	} },
+	session: { fields: { impersonatedBy: {
+		type: "string",
+		required: false
+	} } }
+};
+
+//#endregion
+export { schema };
+//# sourceMappingURL=schema.mjs.map

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

@@ -0,0 +1,22 @@
+import { ANONYMOUS_ERROR_CODES } from "./error-codes.mjs";
+
+//#region src/plugins/anonymous/client.ts
+const anonymousClient = () => {
+	return {
+		id: "anonymous",
+		$InferServerPlugin: {},
+		pathMethods: {
+			"/sign-in/anonymous": "POST",
+			"/delete-anonymous-user": "POST"
+		},
+		atomListeners: [{
+			matcher: (path) => path === "/sign-in/anonymous",
+			signal: "$sessionSignal"
+		}],
+		$ERROR_CODES: ANONYMOUS_ERROR_CODES
+	};
+};
+
+//#endregion
+export { anonymousClient };
+//# sourceMappingURL=client.mjs.map

package/.output/server/node_modules/better-auth/dist/plugins/anonymous/error-codes.mjs

@@ -0,0 +1,16 @@
+import { defineErrorCodes } from "@better-auth/core/utils/error-codes";
+
+//#region src/plugins/anonymous/error-codes.ts
+const ANONYMOUS_ERROR_CODES = defineErrorCodes({
+	INVALID_EMAIL_FORMAT: "Email was not generated in a valid format",
+	FAILED_TO_CREATE_USER: "Failed to create user",
+	COULD_NOT_CREATE_SESSION: "Could not create session",
+	ANONYMOUS_USERS_CANNOT_SIGN_IN_AGAIN_ANONYMOUSLY: "Anonymous users cannot sign in again anonymously",
+	FAILED_TO_DELETE_ANONYMOUS_USER: "Failed to delete anonymous user",
+	USER_IS_NOT_ANONYMOUS: "User is not anonymous",
+	DELETE_ANONYMOUS_USER_DISABLED: "Deleting anonymous users is disabled"
+});
+
+//#endregion
+export { ANONYMOUS_ERROR_CODES };
+//# sourceMappingURL=error-codes.mjs.map

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

@@ -0,0 +1,160 @@
+import { mergeSchema, parseUserOutput } from "../../db/schema.mjs";
+import { parseSetCookieHeader } from "../../cookies/cookie-utils.mjs";
+import { deleteSessionCookie, setSessionCookie } from "../../cookies/index.mjs";
+import { getSessionFromCtx, sensitiveSessionMiddleware } from "../../api/routes/session.mjs";
+import { APIError } from "../../api/index.mjs";
+import { ANONYMOUS_ERROR_CODES } from "./error-codes.mjs";
+import { schema } from "./schema.mjs";
+import { generateId } from "@better-auth/core/utils/id";
+import { createAuthEndpoint, createAuthMiddleware } from "@better-auth/core/api";
+import * as z from "zod";
+
+//#region src/plugins/anonymous/index.ts
+async function getAnonUserEmail(options) {
+	const customEmail = await options?.generateRandomEmail?.();
+	if (customEmail) {
+		if (!z.email().safeParse(customEmail).success) throw APIError.from("BAD_REQUEST", ANONYMOUS_ERROR_CODES.INVALID_EMAIL_FORMAT);
+		return customEmail;
+	}
+	const id = generateId();
+	if (options?.emailDomainName) return `temp-${id}@${options.emailDomainName}`;
+	return `temp@${id}.com`;
+}
+const anonymous = (options) => {
+	return {
+		id: "anonymous",
+		endpoints: {
+			signInAnonymous: createAuthEndpoint("/sign-in/anonymous", {
+				method: "POST",
+				metadata: { openapi: {
+					description: "Sign in anonymously",
+					responses: { 200: {
+						description: "Sign in anonymously",
+						content: { "application/json": { schema: {
+							type: "object",
+							properties: {
+								user: { $ref: "#/components/schemas/User" },
+								session: { $ref: "#/components/schemas/Session" }
+							}
+						} } }
+					} }
+				} }
+			}, async (ctx) => {
+				if ((await getSessionFromCtx(ctx, { disableRefresh: true }))?.user.isAnonymous) throw APIError.from("BAD_REQUEST", ANONYMOUS_ERROR_CODES.ANONYMOUS_USERS_CANNOT_SIGN_IN_AGAIN_ANONYMOUSLY);
+				const email = await getAnonUserEmail(options);
+				const name = await options?.generateName?.(ctx) || "Anonymous";
+				const newUser = await ctx.context.internalAdapter.createUser({
+					email,
+					emailVerified: false,
+					isAnonymous: true,
+					name,
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+				if (!newUser) throw APIError.from("INTERNAL_SERVER_ERROR", ANONYMOUS_ERROR_CODES.FAILED_TO_CREATE_USER);
+				const session = await ctx.context.internalAdapter.createSession(newUser.id);
+				if (!session) throw APIError.from("BAD_REQUEST", ANONYMOUS_ERROR_CODES.COULD_NOT_CREATE_SESSION);
+				await setSessionCookie(ctx, {
+					session,
+					user: newUser
+				});
+				return ctx.json({
+					token: session.token,
+					user: parseUserOutput(ctx.context.options, newUser)
+				});
+			}),
+			deleteAnonymousUser: createAuthEndpoint("/delete-anonymous-user", {
+				method: "POST",
+				use: [sensitiveSessionMiddleware],
+				metadata: { openapi: {
+					description: "Delete an anonymous user",
+					responses: {
+						200: {
+							description: "Anonymous user deleted",
+							content: { "application/json": { schema: {
+								type: "object",
+								properties: { success: { type: "boolean" } }
+							} } }
+						},
+						"400": {
+							description: "Anonymous user deletion is disabled",
+							content: { "application/json": {
+								schema: {
+									type: "object",
+									properties: { message: { type: "string" } }
+								},
+								required: ["message"]
+							} }
+						},
+						"500": {
+							description: "Internal server error",
+							content: { "application/json": { schema: {
+								type: "object",
+								properties: { message: { type: "string" } },
+								required: ["message"]
+							} } }
+						}
+					}
+				} }
+			}, async (ctx) => {
+				const session = ctx.context.session;
+				if (options?.disableDeleteAnonymousUser) throw APIError.from("BAD_REQUEST", ANONYMOUS_ERROR_CODES.DELETE_ANONYMOUS_USER_DISABLED);
+				if (!session.user.isAnonymous) throw APIError.from("FORBIDDEN", ANONYMOUS_ERROR_CODES.USER_IS_NOT_ANONYMOUS);
+				try {
+					await ctx.context.internalAdapter.deleteUser(session.user.id);
+				} catch (error) {
+					ctx.context.logger.error("Failed to delete anonymous user", error);
+					throw APIError.from("INTERNAL_SERVER_ERROR", ANONYMOUS_ERROR_CODES.FAILED_TO_DELETE_ANONYMOUS_USER);
+				}
+				deleteSessionCookie(ctx);
+				return ctx.json({ success: true });
+			})
+		},
+		hooks: { after: [{
+			matcher(ctx) {
+				return ctx.path?.startsWith("/sign-in") || ctx.path?.startsWith("/sign-up") || ctx.path?.startsWith("/callback") || ctx.path?.startsWith("/oauth2/callback") || ctx.path?.startsWith("/magic-link/verify") || ctx.path?.startsWith("/email-otp/verify-email") || ctx.path?.startsWith("/one-tap/callback") || ctx.path?.startsWith("/passkey/verify-authentication") || ctx.path?.startsWith("/phone-number/verify") || false;
+			},
+			handler: createAuthMiddleware(async (ctx) => {
+				const setCookie = ctx.context.responseHeaders?.get("set-cookie");
+				/**
+				* We can consider the user is about to sign in or sign up
+				* if the response contains a session token.
+				*/
+				const sessionTokenName = ctx.context.authCookies.sessionToken.name;
+				if (!parseSetCookieHeader(setCookie || "").get(sessionTokenName)?.value.split(".")[0]) return;
+				/**
+				* Make sure the user had an anonymous session.
+				*/
+				const session = await getSessionFromCtx(ctx, { disableRefresh: true });
+				if (!session || !session.user.isAnonymous) return;
+				if (ctx.path === "/sign-in/anonymous" && !ctx.context.newSession) throw APIError.from("BAD_REQUEST", ANONYMOUS_ERROR_CODES.ANONYMOUS_USERS_CANNOT_SIGN_IN_AGAIN_ANONYMOUSLY);
+				const newSession = ctx.context.newSession;
+				if (!newSession) return;
+				const user = {
+					...session.user,
+					isAnonymous: session.user.isAnonymous
+				};
+				if (options?.onLinkAccount) await options?.onLinkAccount?.({
+					anonymousUser: {
+						session: session.session,
+						user
+					},
+					newUser: newSession,
+					ctx
+				});
+				const newSessionUser = newSession.user;
+				const isSameUser = newSessionUser?.id === session.user.id;
+				const newSessionIsAnonymous = Boolean(newSessionUser?.isAnonymous);
+				if (options?.disableDeleteAnonymousUser || isSameUser || newSessionIsAnonymous) return;
+				await ctx.context.internalAdapter.deleteUser(session.user.id);
+			})
+		}] },
+		options,
+		schema: mergeSchema(schema, options?.schema),
+		$ERROR_CODES: ANONYMOUS_ERROR_CODES
+	};
+};
+
+//#endregion
+export { anonymous };
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,11 @@
+//#region src/plugins/anonymous/schema.ts
+const schema = { user: { fields: { isAnonymous: {
+	type: "boolean",
+	required: false,
+	input: false,
+	defaultValue: false
+} } } };
+
+//#endregion
+export { schema };
+//# sourceMappingURL=schema.mjs.map

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

@@ -0,0 +1,83 @@
+import { parseSetCookieHeader } from "../../cookies/cookie-utils.mjs";
+import "../../cookies/index.mjs";
+import { serializeSignedCookie } from "better-call";
+import { createAuthMiddleware } from "@better-auth/core/api";
+import { createHMAC } from "@better-auth/utils/hmac";
+
+//#region src/plugins/bearer/index.ts
+const BEARER_SCHEME = "bearer ";
+function tryDecode(str) {
+	try {
+		return decodeURIComponent(str);
+	} catch {
+		return str;
+	}
+}
+/**
+* Converts bearer token to session cookie
+*/
+const bearer = (options) => {
+	return {
+		id: "bearer",
+		hooks: {
+			before: [{
+				matcher(context) {
+					return Boolean(context.request?.headers.get("authorization") || context.headers?.get("authorization"));
+				},
+				handler: createAuthMiddleware(async (c) => {
+					const authHeader = c.request?.headers.get("authorization") || c.headers?.get("Authorization");
+					if (!authHeader) return;
+					if (authHeader.slice(0, 7).toLowerCase() !== BEARER_SCHEME) return;
+					const token = authHeader.slice(7).trim();
+					if (!token) return;
+					let signedToken;
+					let decodedToken;
+					if (token.includes(".")) {
+						const isEncoded = token.includes("%");
+						signedToken = isEncoded ? token : encodeURIComponent(token);
+						decodedToken = isEncoded ? tryDecode(token) : token;
+					} else {
+						if (options?.requireSignature) return;
+						signedToken = (await serializeSignedCookie("", token, c.context.secret)).replace("=", "");
+						decodedToken = tryDecode(signedToken);
+					}
+					try {
+						if (!await createHMAC("SHA-256", "base64urlnopad").verify(c.context.secret, decodedToken.split(".")[0], decodedToken.split(".")[1])) return;
+					} catch {
+						return;
+					}
+					const existingHeaders = c.request?.headers || c.headers;
+					const headers = new Headers({ ...Object.fromEntries(existingHeaders?.entries()) });
+					const existingCookie = headers.get("cookie");
+					const newCookie = `${c.context.authCookies.sessionToken.name}=${signedToken}`;
+					headers.set("cookie", existingCookie ? `${existingCookie}; ${newCookie}` : newCookie);
+					return { context: { headers } };
+				})
+			}],
+			after: [{
+				matcher(context) {
+					return true;
+				},
+				handler: createAuthMiddleware(async (ctx) => {
+					const setCookie = ctx.context.responseHeaders?.get("set-cookie");
+					if (!setCookie) return;
+					const parsedCookies = parseSetCookieHeader(setCookie);
+					const cookieName = ctx.context.authCookies.sessionToken.name;
+					const sessionCookie = parsedCookies.get(cookieName);
+					if (!sessionCookie || !sessionCookie.value || sessionCookie["max-age"] === 0) return;
+					const token = sessionCookie.value;
+					const exposedHeaders = ctx.context.responseHeaders?.get("access-control-expose-headers") || "";
+					const headersSet = new Set(exposedHeaders.split(",").map((header) => header.trim()).filter(Boolean));
+					headersSet.add("set-auth-token");
+					ctx.setHeader("set-auth-token", token);
+					ctx.setHeader("Access-Control-Expose-Headers", Array.from(headersSet).join(", "));
+				})
+			}]
+		},
+		options
+	};
+};
+
+//#endregion
+export { bearer };
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,22 @@
+//#region src/plugins/captcha/constants.ts
+const defaultEndpoints = [
+	"/sign-up/email",
+	"/sign-in/email",
+	"/request-password-reset"
+];
+const Providers = {
+	CLOUDFLARE_TURNSTILE: "cloudflare-turnstile",
+	GOOGLE_RECAPTCHA: "google-recaptcha",
+	HCAPTCHA: "hcaptcha",
+	CAPTCHAFOX: "captchafox"
+};
+const siteVerifyMap = {
+	[Providers.CLOUDFLARE_TURNSTILE]: "https://challenges.cloudflare.com/turnstile/v0/siteverify",
+	[Providers.GOOGLE_RECAPTCHA]: "https://www.google.com/recaptcha/api/siteverify",
+	[Providers.HCAPTCHA]: "https://api.hcaptcha.com/siteverify",
+	[Providers.CAPTCHAFOX]: "https://api.captchafox.com/siteverify"
+};
+
+//#endregion
+export { Providers, defaultEndpoints, siteVerifyMap };
+//# sourceMappingURL=constants.mjs.map

package/.output/server/node_modules/better-auth/dist/plugins/captcha/error-codes.mjs

@@ -0,0 +1,16 @@
+import { defineErrorCodes } from "@better-auth/core/utils/error-codes";
+
+//#region src/plugins/captcha/error-codes.ts
+const EXTERNAL_ERROR_CODES = defineErrorCodes({
+	VERIFICATION_FAILED: "Captcha verification failed",
+	MISSING_RESPONSE: "Missing CAPTCHA response",
+	UNKNOWN_ERROR: "Something went wrong"
+});
+const INTERNAL_ERROR_CODES = defineErrorCodes({
+	MISSING_SECRET_KEY: "Missing secret key",
+	SERVICE_UNAVAILABLE: "CAPTCHA service unavailable"
+});
+
+//#endregion
+export { EXTERNAL_ERROR_CODES, INTERNAL_ERROR_CODES };
+//# sourceMappingURL=error-codes.mjs.map

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

@@ -0,0 +1,63 @@
+import { getIp } from "../../utils/get-request-ip.mjs";
+import { middlewareResponse } from "../../utils/middleware-response.mjs";
+import { Providers, defaultEndpoints, siteVerifyMap } from "./constants.mjs";
+import { EXTERNAL_ERROR_CODES, INTERNAL_ERROR_CODES } from "./error-codes.mjs";
+import { captchaFox } from "./verify-handlers/captchafox.mjs";
+import { cloudflareTurnstile } from "./verify-handlers/cloudflare-turnstile.mjs";
+import { googleRecaptcha } from "./verify-handlers/google-recaptcha.mjs";
+import { hCaptcha } from "./verify-handlers/h-captcha.mjs";
+import "./verify-handlers/index.mjs";
+
+//#region src/plugins/captcha/index.ts
+const captcha = (options) => ({
+	id: "captcha",
+	$ERROR_CODES: EXTERNAL_ERROR_CODES,
+	onRequest: async (request, ctx) => {
+		try {
+			if (!(options.endpoints?.length ? options.endpoints : defaultEndpoints).some((endpoint) => request.url.includes(endpoint))) return void 0;
+			if (!options.secretKey) throw new Error(INTERNAL_ERROR_CODES.MISSING_SECRET_KEY.message);
+			const captchaResponse = request.headers.get("x-captcha-response");
+			const remoteUserIP = getIp(request, ctx.options) ?? void 0;
+			if (!captchaResponse) return middlewareResponse({
+				message: EXTERNAL_ERROR_CODES.MISSING_RESPONSE.message,
+				code: EXTERNAL_ERROR_CODES.MISSING_RESPONSE.code,
+				status: 400
+			});
+			const handlerParams = {
+				siteVerifyURL: options.siteVerifyURLOverride || siteVerifyMap[options.provider],
+				captchaResponse,
+				secretKey: options.secretKey,
+				remoteIP: remoteUserIP
+			};
+			if (options.provider === Providers.CLOUDFLARE_TURNSTILE) return await cloudflareTurnstile(handlerParams);
+			if (options.provider === Providers.GOOGLE_RECAPTCHA) return await googleRecaptcha({
+				...handlerParams,
+				minScore: options.minScore
+			});
+			if (options.provider === Providers.HCAPTCHA) return await hCaptcha({
+				...handlerParams,
+				siteKey: options.siteKey
+			});
+			if (options.provider === Providers.CAPTCHAFOX) return await captchaFox({
+				...handlerParams,
+				siteKey: options.siteKey
+			});
+		} catch (_error) {
+			const errorMessage = _error instanceof Error ? _error.message : void 0;
+			ctx.logger.error(errorMessage ?? "Unknown error", {
+				endpoint: request.url,
+				message: _error
+			});
+			return middlewareResponse({
+				message: EXTERNAL_ERROR_CODES.UNKNOWN_ERROR.message,
+				code: EXTERNAL_ERROR_CODES.UNKNOWN_ERROR.code,
+				status: 500
+			});
+		}
+	},
+	options
+});
+
+//#endregion
+export { captcha };
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,11 @@
+//#region src/plugins/captcha/utils.ts
+const encodeToURLParams = (obj) => {
+	if (typeof obj !== "object" || obj === null || Array.isArray(obj)) throw new Error("Input must be a non-null object.");
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(obj)) if (value !== void 0 && value !== null) params.append(key, String(value));
+	return params.toString();
+};
+
+//#endregion
+export { encodeToURLParams };
+//# sourceMappingURL=utils.mjs.map

package/.output/server/node_modules/better-auth/dist/plugins/captcha/verify-handlers/captchafox.mjs

@@ -0,0 +1,28 @@
+import { middlewareResponse } from "../../../utils/middleware-response.mjs";
+import { EXTERNAL_ERROR_CODES, INTERNAL_ERROR_CODES } from "../error-codes.mjs";
+import { encodeToURLParams } from "../utils.mjs";
+import { betterFetch } from "@better-fetch/fetch";
+
+//#region src/plugins/captcha/verify-handlers/captchafox.ts
+const captchaFox = async ({ siteVerifyURL, captchaResponse, secretKey, siteKey, remoteIP }) => {
+	const response = await betterFetch(siteVerifyURL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: encodeToURLParams({
+			secret: secretKey,
+			response: captchaResponse,
+			...siteKey && { sitekey: siteKey },
+			...remoteIP && { remoteIp: remoteIP }
+		})
+	});
+	if (!response.data || response.error) throw new Error(INTERNAL_ERROR_CODES.SERVICE_UNAVAILABLE.message);
+	if (!response.data.success) return middlewareResponse({
+		message: EXTERNAL_ERROR_CODES.VERIFICATION_FAILED.message,
+		code: EXTERNAL_ERROR_CODES.VERIFICATION_FAILED.code,
+		status: 403
+	});
+};
+
+//#endregion
+export { captchaFox };
+//# sourceMappingURL=captchafox.mjs.map

package/.output/server/node_modules/better-auth/dist/plugins/captcha/verify-handlers/cloudflare-turnstile.mjs

@@ -0,0 +1,26 @@
+import { middlewareResponse } from "../../../utils/middleware-response.mjs";
+import { EXTERNAL_ERROR_CODES, INTERNAL_ERROR_CODES } from "../error-codes.mjs";
+import { betterFetch } from "@better-fetch/fetch";
+
+//#region src/plugins/captcha/verify-handlers/cloudflare-turnstile.ts
+const cloudflareTurnstile = async ({ siteVerifyURL, captchaResponse, secretKey, remoteIP }) => {
+	const response = await betterFetch(siteVerifyURL, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			secret: secretKey,
+			response: captchaResponse,
+			...remoteIP && { remoteip: remoteIP }
+		})
+	});
+	if (!response.data || response.error) throw new Error(INTERNAL_ERROR_CODES.SERVICE_UNAVAILABLE.message);
+	if (!response.data.success) return middlewareResponse({
+		message: EXTERNAL_ERROR_CODES.VERIFICATION_FAILED.message,
+		code: EXTERNAL_ERROR_CODES.VERIFICATION_FAILED.code,
+		status: 403
+	});
+};
+
+//#endregion
+export { cloudflareTurnstile };
+//# sourceMappingURL=cloudflare-turnstile.mjs.map

package/.output/server/node_modules/better-auth/dist/plugins/captcha/verify-handlers/google-recaptcha.mjs

@@ -0,0 +1,30 @@
+import { middlewareResponse } from "../../../utils/middleware-response.mjs";
+import { EXTERNAL_ERROR_CODES, INTERNAL_ERROR_CODES } from "../error-codes.mjs";
+import { encodeToURLParams } from "../utils.mjs";
+import { betterFetch } from "@better-fetch/fetch";
+
+//#region src/plugins/captcha/verify-handlers/google-recaptcha.ts
+const isV3 = (response) => {
+	return "score" in response && typeof response.score === "number";
+};
+const googleRecaptcha = async ({ siteVerifyURL, captchaResponse, secretKey, minScore = .5, remoteIP }) => {
+	const response = await betterFetch(siteVerifyURL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: encodeToURLParams({
+			secret: secretKey,
+			response: captchaResponse,
+			...remoteIP && { remoteip: remoteIP }
+		})
+	});
+	if (!response.data || response.error) throw new Error(INTERNAL_ERROR_CODES.SERVICE_UNAVAILABLE.message);
+	if (!response.data.success || isV3(response.data) && response.data.score < minScore) return middlewareResponse({
+		message: EXTERNAL_ERROR_CODES.VERIFICATION_FAILED.message,
+		code: EXTERNAL_ERROR_CODES.VERIFICATION_FAILED.code,
+		status: 403
+	});
+};
+
+//#endregion
+export { googleRecaptcha };
+//# sourceMappingURL=google-recaptcha.mjs.map

package/.output/server/node_modules/better-auth/dist/plugins/captcha/verify-handlers/h-captcha.mjs

@@ -0,0 +1,28 @@
+import { middlewareResponse } from "../../../utils/middleware-response.mjs";
+import { EXTERNAL_ERROR_CODES, INTERNAL_ERROR_CODES } from "../error-codes.mjs";
+import { encodeToURLParams } from "../utils.mjs";
+import { betterFetch } from "@better-fetch/fetch";
+
+//#region src/plugins/captcha/verify-handlers/h-captcha.ts
+const hCaptcha = async ({ siteVerifyURL, captchaResponse, secretKey, siteKey, remoteIP }) => {
+	const response = await betterFetch(siteVerifyURL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: encodeToURLParams({
+			secret: secretKey,
+			response: captchaResponse,
+			...siteKey && { sitekey: siteKey },
+			...remoteIP && { remoteip: remoteIP }
+		})
+	});
+	if (!response.data || response.error) throw new Error(INTERNAL_ERROR_CODES.SERVICE_UNAVAILABLE.message);
+	if (!response.data.success) return middlewareResponse({
+		message: EXTERNAL_ERROR_CODES.VERIFICATION_FAILED.message,
+		code: EXTERNAL_ERROR_CODES.VERIFICATION_FAILED.code,
+		status: 403
+	});
+};
+
+//#endregion
+export { hCaptcha };
+//# sourceMappingURL=h-captcha.mjs.map

package/.output/server/node_modules/better-auth/dist/plugins/captcha/verify-handlers/index.mjs

@@ -0,0 +1,6 @@
+import { captchaFox } from "./captchafox.mjs";
+import { cloudflareTurnstile } from "./cloudflare-turnstile.mjs";
+import { googleRecaptcha } from "./google-recaptcha.mjs";
+import { hCaptcha } from "./h-captcha.mjs";
+
+export {  };

package/.output/server/node_modules/better-auth/dist/plugins/custom-session/client.mjs

@@ -0,0 +1,11 @@
+import { InferServerPlugin } from "../../client/plugins/infer-plugin.mjs";
+import "../../client/plugins/index.mjs";
+
+//#region src/plugins/custom-session/client.ts
+const customSessionClient = () => {
+	return InferServerPlugin();
+};
+
+//#endregion
+export { customSessionClient };
+//# sourceMappingURL=client.mjs.map

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

@@ -0,0 +1,78 @@
+import { parseSetCookieHeader } from "../../cookies/cookie-utils.mjs";
+import { getSession } from "../../api/routes/session.mjs";
+import "../../api/index.mjs";
+import { getEndpointResponse } from "../../utils/plugin-helper.mjs";
+import { createAuthEndpoint, createAuthMiddleware } from "@better-auth/core/api";
+import * as z from "zod";
+
+//#region src/plugins/custom-session/index.ts
+const getSessionQuerySchema = z.optional(z.object({
+	disableCookieCache: z.boolean().meta({ description: "Disable cookie cache and fetch session from database" }).or(z.string().transform((v) => v === "true")).optional(),
+	disableRefresh: z.boolean().meta({ description: "Disable session refresh. Useful for checking session status, without updating the session" }).optional()
+}));
+const customSession = (fn, options, pluginOptions) => {
+	return {
+		id: "custom-session",
+		hooks: { after: [{
+			matcher: (ctx) => ctx.path === "/multi-session/list-device-sessions" && (pluginOptions?.shouldMutateListDeviceSessionsEndpoint ?? false),
+			handler: createAuthMiddleware(async (ctx) => {
+				const response = await getEndpointResponse(ctx);
+				if (!response) return;
+				const newResponse = await Promise.all(response.map(async (v) => await fn(v, ctx)));
+				return ctx.json(newResponse);
+			})
+		}] },
+		endpoints: { getSession: createAuthEndpoint("/get-session", {
+			method: "GET",
+			query: getSessionQuerySchema,
+			metadata: {
+				CUSTOM_SESSION: true,
+				openapi: {
+					description: "Get custom session data",
+					responses: { "200": {
+						description: "Success",
+						content: { "application/json": { schema: {
+							type: "array",
+							nullable: true,
+							items: { $ref: "#/components/schemas/Session" }
+						} } }
+					} }
+				}
+			},
+			requireHeaders: true
+		}, async (ctx) => {
+			const session = await getSession()({
+				...ctx,
+				asResponse: false,
+				headers: ctx.headers,
+				returnHeaders: true
+			}).catch((e) => {
+				return null;
+			});
+			if (!session?.response) return ctx.json(null);
+			const fnResult = await fn(session.response, ctx);
+			for (const cookieStr of session.headers.getSetCookie()) parseSetCookieHeader(cookieStr).forEach((attrs, name) => {
+				ctx.setCookie(name, attrs.value, {
+					maxAge: attrs["max-age"],
+					expires: attrs.expires,
+					domain: attrs.domain,
+					path: attrs.path,
+					secure: attrs.secure,
+					httpOnly: attrs.httponly,
+					sameSite: attrs.samesite
+				});
+			});
+			session.headers.delete("set-cookie");
+			session.headers.forEach((value, key) => {
+				ctx.setHeader(key, value);
+			});
+			return ctx.json(fnResult);
+		}) },
+		$Infer: { Session: {} },
+		options: pluginOptions
+	};
+};
+
+//#endregion
+export { customSession };
+//# sourceMappingURL=index.mjs.map