@soorya-u/better-auth-desktop 0.1.0

package/dist/server/index.mjs

@@ -0,0 +1,213 @@
+import { t as PACKAGE_VERSION } from "../version-1hEssvcU.mjs";
+import { a as parseLoopbackUrl } from "../loopback-DTQgg1Za.mjs";
+import { setSessionCookie } from "better-auth/cookies";
+import { APIError, BASE_ERROR_CODES } from "@better-auth/core/error";
+import { base64Url } from "@better-auth/utils/base64";
+import { createHash } from "@better-auth/utils/hash";
+import { defineErrorCodes } from "better-auth";
+import { generateRandomString } from "better-auth/crypto";
+import { createAuthMiddleware } from "@better-auth/core/api";
+import { Buffer } from "node:buffer";
+import { timingSafeEqual } from "node:crypto";
+import { SocialProviderListEnum } from "@better-auth/core/social-providers";
+import { safeJSONParse as safeJSONParse$1 } from "@better-auth/core/utils/json";
+import { betterFetch } from "@better-fetch/fetch";
+import { createAuthEndpoint, sessionMiddleware } from "better-auth/api";
+import { parseUserOutput } from "better-auth/db";
+import * as z from "zod";
+//#region src/server/error-codes.ts
+const DESKTOP_ERROR_CODES = defineErrorCodes({
+	INVALID_CLIENT_ID: "Invalid client ID",
+	INVALID_TOKEN: "Invalid or expired token.",
+	STATE_MISMATCH: "state mismatch",
+	MISSING_CODE_CHALLENGE: "missing code challenge",
+	INVALID_CODE_VERIFIER: "Invalid code verifier",
+	MISSING_STATE: "state is required",
+	MISSING_PKCE: "pkce is required",
+	INVALID_PKCE_METHOD: "PKCE method must be S256",
+	INVALID_LOOPBACK_URL: "callbackURL must be a http://127.0.0.1 loopback URL"
+});
+//#endregion
+//#region src/server/routes.ts
+const desktopToken = (_opts) => createAuthEndpoint("/desktop/token", {
+	method: "POST",
+	body: z.object({
+		token: z.string().nonempty(),
+		state: z.string().nonempty(),
+		code_verifier: z.string().nonempty()
+	}),
+	metadata: { scope: "http" }
+}, async (ctx) => {
+	const token = await ctx.context.internalAdapter.consumeVerificationValue(`desktop:${ctx.body.token}`);
+	if (!token) throw APIError.from("NOT_FOUND", DESKTOP_ERROR_CODES.INVALID_TOKEN);
+	const tokenRecord = safeJSONParse$1(token.value);
+	if (!tokenRecord) throw APIError.from("INTERNAL_SERVER_ERROR", DESKTOP_ERROR_CODES.INVALID_TOKEN);
+	if (tokenRecord.state !== ctx.body.state) throw APIError.from("BAD_REQUEST", DESKTOP_ERROR_CODES.STATE_MISMATCH);
+	if (!tokenRecord.codeChallenge) throw APIError.from("BAD_REQUEST", DESKTOP_ERROR_CODES.MISSING_CODE_CHALLENGE);
+	if (tokenRecord.codeChallengeMethod !== "s256") throw APIError.from("BAD_REQUEST", DESKTOP_ERROR_CODES.INVALID_PKCE_METHOD);
+	const codeChallenge = Buffer.from(base64Url.decode(tokenRecord.codeChallenge));
+	const codeVerifier = Buffer.from(await createHash("SHA-256").digest(ctx.body.code_verifier));
+	if (codeChallenge.length !== codeVerifier.length || !timingSafeEqual(codeChallenge, codeVerifier)) throw APIError.from("BAD_REQUEST", DESKTOP_ERROR_CODES.INVALID_CODE_VERIFIER);
+	const user = await ctx.context.internalAdapter.findUserById(tokenRecord.userId);
+	if (!user) throw APIError.from("INTERNAL_SERVER_ERROR", BASE_ERROR_CODES.USER_NOT_FOUND);
+	const session = await ctx.context.internalAdapter.createSession(user.id);
+	if (!session) throw APIError.from("INTERNAL_SERVER_ERROR", BASE_ERROR_CODES.FAILED_TO_CREATE_SESSION);
+	await setSessionCookie(ctx, {
+		session,
+		user
+	});
+	return ctx.json({
+		token: session.token,
+		user: parseUserOutput(ctx.context.options, user)
+	});
+});
+const desktopInitOAuthProxy = (opts) => createAuthEndpoint("/desktop/init-oauth-proxy", {
+	method: "GET",
+	query: z.object({
+		provider: z.string().nonempty(),
+		state: z.string(),
+		code_challenge: z.string(),
+		code_challenge_method: z.string().optional(),
+		callbackURL: z.string().nonempty()
+	}),
+	metadata: { scope: "http" }
+}, async (ctx) => {
+	const loopback = parseLoopbackUrl(ctx.query.callbackURL, opts.allowedLoopbackPorts);
+	if (!loopback) throw APIError.from("BAD_REQUEST", DESKTOP_ERROR_CODES.INVALID_LOOPBACK_URL);
+	const isSocialProvider = SocialProviderListEnum.safeParse(ctx.query.provider);
+	if (!isSocialProvider && !ctx.context.getPlugin("generic-oauth")) throw APIError.from("BAD_REQUEST", BASE_ERROR_CODES.PROVIDER_NOT_FOUND);
+	if (ctx.query.code_challenge_method && ctx.query.code_challenge_method.toLowerCase() !== "s256") throw APIError.from("BAD_REQUEST", DESKTOP_ERROR_CODES.INVALID_PKCE_METHOD);
+	const headers = new Headers(ctx.request?.headers);
+	headers.set("origin", new URL(ctx.context.baseURL).origin);
+	let setCookie = null;
+	const searchParams = new URLSearchParams();
+	searchParams.set("client_id", opts.clientID);
+	searchParams.set("code_challenge", ctx.query.code_challenge);
+	searchParams.set("code_challenge_method", "S256");
+	searchParams.set("state", ctx.query.state);
+	const completeURL = new URL(`${ctx.context.baseURL}/desktop/oauth-complete`);
+	completeURL.searchParams.set("redirect", loopback.toString());
+	const res = await betterFetch(`${isSocialProvider ? "/sign-in/social" : "/sign-in/oauth2"}?${searchParams.toString()}`, {
+		baseURL: ctx.context.baseURL,
+		method: "POST",
+		body: {
+			provider: ctx.query.provider,
+			callbackURL: completeURL.toString()
+		},
+		onResponse: (ctx) => {
+			setCookie = ctx.response.headers.get("set-cookie") ?? null;
+		},
+		headers
+	});
+	if (res.error) throw new APIError("INTERNAL_SERVER_ERROR", { message: res.error.message || "An unknown error occurred." });
+	if (setCookie) ctx.setHeader("set-cookie", setCookie);
+	const cookie = ctx.context.createAuthCookie("transfer_token", { maxAge: opts.codeExpiresIn });
+	await ctx.setSignedCookie(cookie.name, JSON.stringify({
+		client_id: opts.clientID,
+		state: ctx.query.state,
+		code_challenge: ctx.query.code_challenge,
+		code_challenge_method: ctx.query.code_challenge_method ?? "S256"
+	}), ctx.context.secret, cookie.attributes);
+	if (res.data.url && res.data.redirect) {
+		ctx.setHeader("Location", res.data.url);
+		ctx.setStatus(302);
+		return;
+	}
+	return ctx.json(res.data);
+});
+const desktopOAuthComplete = (opts, { handleTransfer }) => createAuthEndpoint("/desktop/oauth-complete", {
+	method: "GET",
+	query: z.object({ redirect: z.string().nonempty() }),
+	use: [sessionMiddleware],
+	requireHeaders: true,
+	metadata: { scope: "http" }
+}, async (ctx) => {
+	const loopback = parseLoopbackUrl(ctx.query.redirect, opts.allowedLoopbackPorts);
+	if (!loopback) throw APIError.from("BAD_REQUEST", DESKTOP_ERROR_CODES.INVALID_LOOPBACK_URL);
+	const cookie = ctx.context.createAuthCookie("transfer_token", { maxAge: opts.codeExpiresIn });
+	const transferCookie = await ctx.getSignedCookie(cookie.name, ctx.context.secret);
+	ctx.setCookie(cookie.name, "", {
+		...cookie.attributes,
+		maxAge: 0
+	});
+	const payload = transferCookie ? safeJSONParse$1(transferCookie) : null;
+	if (!payload) throw APIError.from("BAD_REQUEST", DESKTOP_ERROR_CODES.MISSING_STATE);
+	const identifier = await handleTransfer(ctx, payload);
+	if (identifier === null) throw APIError.from("BAD_REQUEST", DESKTOP_ERROR_CODES.INVALID_CLIENT_ID);
+	const redirectToken = base64Url.encode(new TextEncoder().encode(JSON.stringify({
+		identifier,
+		state: payload.state
+	})));
+	if (opts.webCallbackUrl) {
+		ctx.setHeader("Location", `${opts.webCallbackUrl}#${opts.hashKey}=${redirectToken}&loopback=${encodeURIComponent(loopback.toString())}`);
+		ctx.setStatus(302);
+		return;
+	}
+	loopback.searchParams.set(opts.hashKey, redirectToken);
+	ctx.setHeader("Location", loopback.toString());
+	ctx.setStatus(302);
+});
+//#endregion
+//#region src/server/plugin.ts
+const isAuthPath = (ctx) => !!(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("/verify-email") || ctx.path?.startsWith("/one-tap/callback") || ctx.path?.startsWith("/passkey/verify-authentication") || ctx.path?.startsWith("/phone-number/verify"));
+const betterAuthDesktop = (options) => {
+	const opts = {
+		clientID: options?.clientID ?? "desktop",
+		codeExpiresIn: options?.codeExpiresIn ?? 300,
+		hashKey: options?.hashKey ?? "token",
+		webCallbackUrl: options?.webCallbackUrl,
+		allowedLoopbackPorts: options?.allowedLoopbackPorts
+	};
+	const disableOriginOverride = options?.disableOriginOverride;
+	const handleTransfer = async (ctx, payload) => {
+		const { client_id, state, code_challenge, code_challenge_method } = payload;
+		const userId = ctx.context.session?.user.id || ctx.context.newSession?.user.id;
+		if (!userId || client_id !== opts.clientID) return null;
+		if (!state) throw APIError.from("BAD_REQUEST", DESKTOP_ERROR_CODES.MISSING_STATE);
+		if (!code_challenge) throw APIError.from("BAD_REQUEST", DESKTOP_ERROR_CODES.MISSING_PKCE);
+		if (code_challenge_method?.toLowerCase() !== "s256") throw APIError.from("BAD_REQUEST", DESKTOP_ERROR_CODES.INVALID_PKCE_METHOD);
+		const identifier = generateRandomString(32, "a-z", "A-Z", "0-9");
+		const expiresAt = new Date(Date.now() + opts.codeExpiresIn * 1e3);
+		await ctx.context.internalAdapter.createVerificationValue({
+			identifier: `desktop:${identifier}`,
+			value: JSON.stringify({
+				userId,
+				codeChallenge: code_challenge,
+				codeChallengeMethod: "s256",
+				state
+			}),
+			expiresAt
+		});
+		return identifier;
+	};
+	return {
+		id: "desktop",
+		version: PACKAGE_VERSION,
+		async onRequest(request, _ctx) {
+			if (disableOriginOverride || request.headers.get("origin")) return;
+			const desktopOrigin = request.headers.get("desktop-origin");
+			if (!desktopOrigin) return;
+			const headers = new Headers(request.headers);
+			headers.set("origin", desktopOrigin);
+			return { request: new Request(request, { headers }) };
+		},
+		hooks: { after: [{
+			matcher: (ctx) => !isAuthPath(ctx),
+			handler: createAuthMiddleware(async (ctx) => {
+				const cookie = ctx.context.createAuthCookie("transfer_token", { maxAge: opts.codeExpiresIn });
+				const transferCookie = await ctx.getSignedCookie(cookie.name, ctx.context.secret);
+				if (!ctx.context.newSession?.session || !transferCookie) return;
+				await ctx.setSignedCookie(cookie.name, transferCookie, ctx.context.secret, cookie.attributes);
+			})
+		}] },
+		endpoints: {
+			desktopToken: desktopToken(opts),
+			desktopInitOAuthProxy: desktopInitOAuthProxy(opts),
+			desktopOAuthComplete: desktopOAuthComplete(opts, { handleTransfer })
+		},
+		options: opts,
+		$ERROR_CODES: DESKTOP_ERROR_CODES
+	};
+};
+//#endregion
+export { DESKTOP_ERROR_CODES, betterAuthDesktop };

package/dist/storage-BcwDmS-W.mjs

@@ -0,0 +1,30 @@
+//#region src/core/storage.ts
+async function keychainStorage(opts = {}) {
+	const { service = "better-auth-desktop", account = "session" } = opts;
+	let cache = {};
+	try {
+		const raw = await Bun.secrets.get({
+			service,
+			name: account
+		});
+		if (raw) cache = JSON.parse(raw);
+	} catch {
+		cache = {};
+	}
+	const persist = () => {
+		Bun.secrets.set({
+			service,
+			name: account,
+			value: JSON.stringify(cache)
+		}).catch(() => void 0);
+	};
+	return {
+		getItem: (name) => cache[name] ?? null,
+		setItem: (name, value) => {
+			cache[name] = value;
+			persist();
+		}
+	};
+}
+//#endregion
+export { keychainStorage as t };

package/dist/storage-DtgX_vmE.d.mts

@@ -0,0 +1,10 @@
+import { l as Storage } from "./types-h9AEfSnq.mjs";
+
+//#region src/core/storage.d.ts
+type KeychainStorageOptions = {
+  service?: string | undefined;
+  account?: string | undefined;
+};
+declare function keychainStorage(opts?: KeychainStorageOptions): Promise<Storage>;
+//#endregion
+export { keychainStorage as n, KeychainStorageOptions as t };

package/dist/types-h9AEfSnq.d.mts

@@ -0,0 +1,75 @@
+import { BetterFetchError } from "@better-fetch/fetch";
+import { Awaitable } from "@better-auth/core";
+import { User } from "@better-auth/core/db";
+
+//#region src/core/types.d.ts
+type AuthUser = User & Record<string, any>;
+/** Synchronous key/value store, typically keychain-backed. */
+type Storage = {
+  getItem: (name: string) => unknown | null;
+  setItem: (name: string, value: unknown) => void;
+};
+/** A single hit on the loopback listener, normalized across runtimes. */
+type LoopbackRequest = {
+  path: string;
+  query: Record<string, string>;
+};
+type LoopbackResponse = {
+  status: number;
+  headers?: Record<string, string>;
+  body: string;
+};
+type LoopbackServer = {
+  port: number;
+  close: () => void;
+};
+/** Events the core pushes to the renderer through the adapter. */
+type AuthEvent = {
+  type: "authenticated";
+  user: AuthUser;
+} | {
+  type: "user-updated";
+  user: AuthUser | null;
+} | {
+  type: "error";
+  error: BetterFetchError | Error;
+  path?: string;
+};
+/**
+ * The only per-runtime surface. An adapter binds a 127.0.0.1 socket, opens the
+ * system browser, pushes events to the renderer, and provides keychain storage;
+ * the loopback flow itself lives in framework-agnostic core.
+ */
+type DesktopAdapter = {
+  openExternal: (url: string) => Awaitable<void>;
+  serveLoopback: (onRequest: (req: LoopbackRequest) => Promise<LoopbackResponse>, opts?: {
+    port?: number;
+  }) => Promise<LoopbackServer>;
+  notifyRenderer: (event: AuthEvent) => void;
+  storage: Storage;
+};
+/** Renderer-initiated sign-in request. `provider` is required for loopback. */
+type RequestAuthOptions = {
+  provider: string;
+  [key: string]: unknown;
+};
+type DesktopClientOptions = {
+  clientID?: string; /** Loopback path the browser is redirected back to. @default "/callback" */
+  loopbackPath?: string; /** Fixed loopback port; omit to bind 127.0.0.1:0 (OS-assigned). */
+  loopbackPort?: number; /** Milliseconds to keep the loopback open awaiting the redirect. @default 300000 */
+  loopbackTimeout?: number;
+  storagePrefix?: string;
+  cookiePrefix?: string | string[];
+  disableCache?: boolean;
+  sanitizeUser?: (user: AuthUser) => Awaitable<AuthUser>;
+  /**
+   * What the loopback shows after a successful exchange. A string is used as the
+   * HTML body; an object can redirect the browser to your own page instead.
+   * Defaults to a built-in "you can close this tab" page.
+   */
+  loopbackSuccess?: string | {
+    redirectTo: string;
+  };
+};
+//#endregion
+export { LoopbackRequest as a, RequestAuthOptions as c, DesktopClientOptions as i, Storage as l, AuthUser as n, LoopbackResponse as o, DesktopAdapter as r, LoopbackServer as s, AuthEvent as t };

package/dist/version-1hEssvcU.mjs

@@ -0,0 +1,5 @@
+//#endregion
+//#region src/version.ts
+const PACKAGE_VERSION = "0.1.0";
+//#endregion
+export { PACKAGE_VERSION as t };

package/dist/web/index.d.mts

@@ -0,0 +1,32 @@
+//#region src/web/forward-to-desktop.d.ts
+type ForwardToDesktopOptions = {
+  /** Must match the server plugin's `hashKey`. @default "token" */hashKey?: string;
+};
+/**
+ * Opt-in successor to the old scheme-based `forwardCallback`. On a branded
+ * `webCallbackUrl` page, reads `#token=…&loopback=…` from the fragment and
+ * performs a **top-level navigation** to the desktop loopback
+ * (`http://127.0.0.1:<port>/…?token=…`) — no CORS / PNA / mixed-content.
+ *
+ * Returns `false` (a no-op) outside a browser or when the fragment is absent,
+ * so it is safe to call unconditionally on the callback page.
+ */
+declare function forwardToDesktop(options?: ForwardToDesktopOptions): boolean;
+/**
+ * Better Auth client plugin wrapping {@link forwardToDesktop}, for consumers
+ * that prefer the `createAuthClient({ plugins: [...] })` pattern:
+ *
+ * ```ts
+ * const authClient = createAuthClient({ plugins: [webDesktop()] });
+ * authClient.forwardToDesktop();
+ * ```
+ */
+declare const webDesktop: (options?: ForwardToDesktopOptions) => {
+  id: "desktop-web";
+  version: string;
+  getActions: () => {
+    forwardToDesktop: () => boolean;
+  };
+};
+//#endregion
+export { type ForwardToDesktopOptions, forwardToDesktop, webDesktop };

package/dist/web/index.mjs

@@ -0,0 +1,41 @@
+import { t as PACKAGE_VERSION } from "../version-1hEssvcU.mjs";
+import { a as parseLoopbackUrl } from "../loopback-DTQgg1Za.mjs";
+//#region src/web/forward-to-desktop.ts
+/**
+* Opt-in successor to the old scheme-based `forwardCallback`. On a branded
+* `webCallbackUrl` page, reads `#token=…&loopback=…` from the fragment and
+* performs a **top-level navigation** to the desktop loopback
+* (`http://127.0.0.1:<port>/…?token=…`) — no CORS / PNA / mixed-content.
+*
+* Returns `false` (a no-op) outside a browser or when the fragment is absent,
+* so it is safe to call unconditionally on the callback page.
+*/
+function forwardToDesktop(options) {
+	if (typeof window === "undefined" || !window) return false;
+	const hashKey = options?.hashKey ?? "token";
+	const params = new URLSearchParams(window.location.hash.replace(/^#/, ""));
+	const token = params.get(hashKey);
+	const loopback = params.get("loopback");
+	if (!token || !loopback) return false;
+	const target = parseLoopbackUrl(decodeURIComponent(loopback));
+	if (!target) return false;
+	target.searchParams.set(hashKey, token);
+	window.location.replace(target.toString());
+	return true;
+}
+/**
+* Better Auth client plugin wrapping {@link forwardToDesktop}, for consumers
+* that prefer the `createAuthClient({ plugins: [...] })` pattern:
+*
+* ```ts
+* const authClient = createAuthClient({ plugins: [webDesktop()] });
+* authClient.forwardToDesktop();
+* ```
+*/
+const webDesktop = (options) => ({
+	id: "desktop-web",
+	version: PACKAGE_VERSION,
+	getActions: () => ({ forwardToDesktop: () => forwardToDesktop(options) })
+});
+//#endregion
+export { forwardToDesktop, webDesktop };

package/package.json

@@ -0,0 +1,153 @@
+{
+	"name": "@soorya-u/better-auth-desktop",
+	"version": "0.1.0",
+	"description": "Loopback-based desktop auth for Better Auth. Framework-agnostic server + core with thin Electrobun and Electron adapters; OAuth hand-off via a 127.0.0.1 loopback navigation (no custom URL scheme).",
+	"type": "module",
+	"license": "MIT",
+	"homepage": "https://github.com/soorya-u/better-auth-electrobun",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/soorya-u/better-auth-electrobun.git"
+	},
+	"keywords": [
+		"electrobun",
+		"electron",
+		"auth",
+		"better-auth",
+		"desktop",
+		"loopback",
+		"typescript"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"sideEffects": false,
+	"scripts": {
+		"build": "tsdown",
+		"dev": "tsdown --watch",
+		"lint:package": "publint run --strict --pack false",
+		"lint:types": "attw --profile esm-only --pack .",
+		"typecheck": "tsc --project tsconfig.typecheck.json --noEmit",
+		"test": "vitest",
+		"coverage": "vitest run --coverage --coverage.provider=istanbul",
+		"check": "biome check",
+		"fix": "biome check --fix --assist-enabled=true"
+	},
+	"files": [
+		"dist",
+		"README.md"
+	],
+	"main": "./dist/index.mjs",
+	"module": "./dist/index.mjs",
+	"types": "./dist/index.d.mts",
+	"exports": {
+		".": {
+			"dev-source": "./src/index.ts",
+			"types": "./dist/index.d.mts",
+			"default": "./dist/index.mjs"
+		},
+		"./server": {
+			"dev-source": "./src/server/index.ts",
+			"types": "./dist/server/index.d.mts",
+			"default": "./dist/server/index.mjs"
+		},
+		"./client": {
+			"dev-source": "./src/client.ts",
+			"types": "./dist/client.d.mts",
+			"default": "./dist/client.mjs"
+		},
+		"./core": {
+			"dev-source": "./src/core/index.ts",
+			"types": "./dist/core/index.d.mts",
+			"default": "./dist/core/index.mjs"
+		},
+		"./electrobun": {
+			"dev-source": "./src/adapters/electrobun.ts",
+			"types": "./dist/adapters/electrobun.d.mts",
+			"default": "./dist/adapters/electrobun.mjs"
+		},
+		"./electron": {
+			"dev-source": "./src/adapters/electron.ts",
+			"types": "./dist/adapters/electron.d.mts",
+			"default": "./dist/adapters/electron.mjs"
+		},
+		"./web": {
+			"dev-source": "./src/web/index.ts",
+			"types": "./dist/web/index.d.mts",
+			"default": "./dist/web/index.mjs"
+		},
+		"./rpc/webview": {
+			"dev-source": "./src/rpc/webview.ts",
+			"types": "./dist/rpc/webview.d.mts",
+			"default": "./dist/rpc/webview.mjs"
+		}
+	},
+	"typesVersions": {
+		"*": {
+			"*": [
+				"./dist/index.d.mts"
+			],
+			"server": [
+				"./dist/server/index.d.mts"
+			],
+			"client": [
+				"./dist/client.d.mts"
+			],
+			"core": [
+				"./dist/core/index.d.mts"
+			],
+			"electrobun": [
+				"./dist/adapters/electrobun.d.mts"
+			],
+			"electron": [
+				"./dist/adapters/electron.d.mts"
+			],
+			"web": [
+				"./dist/web/index.d.mts"
+			],
+			"rpc/webview": [
+				"./dist/rpc/webview.d.mts"
+			]
+		}
+	},
+	"dependencies": {
+		"zod": "^4.3.6"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.5.1",
+		"@types/better-sqlite3": "^7.6.13",
+		"@types/bun": "latest",
+		"better-auth": "^1.6.21",
+		"better-call": "1.3.7",
+		"better-sqlite3": "^12.11.1",
+		"electrobun": "^1.18.1",
+		"publint": "^0.3.12",
+		"tsdown": "^0.21.1",
+		"typescript": "^5.9.3",
+		"vitest": "^4.1.5"
+	},
+	"peerDependencies": {
+		"@better-auth/core": "^1.6.21",
+		"@better-auth/utils": "^0.4.2",
+		"@better-fetch/fetch": "^1.3.1",
+		"better-auth": "^1.6.21",
+		"better-call": "^1.3.7",
+		"electron": ">=28.0.0",
+		"electron-store": ">=8.2.0",
+		"electrobun": ">=1.18.1"
+	},
+	"peerDependenciesMeta": {
+		"electrobun": {
+			"optional": true
+		},
+		"electron": {
+			"optional": true
+		},
+		"electron-store": {
+			"optional": true
+		}
+	},
+	"engines": {
+		"node": ">=22.0.0"
+	}
+}