@dbx-tools/auth-gate 0.6.168

package/README.md

@@ -0,0 +1,50 @@
+# `@dbx-tools/auth-gate`
+
+Passwordless authentication runtime built on Better Auth, email OTP, passkeys,
+and caller-provided identity policy and delivery.
+
+Key features:
+
+- Better Auth ownership of users, sessions, OTP lifecycle, rate limits, and
+  passkey credentials;
+- session-required passkey enrollment and discoverable passkey login;
+- POST and browser-redirect logout routes with a same-origin destination;
+- caller-provided `authorizeIdentity`, email sender, secret, origin, and
+  database;
+- native AppKit Lakebase pool or local SQLite storage;
+- programmatic Better Auth migrations under advisory or file locks.
+
+## Relationship To Native AppKit
+
+Use the Databricks Apps front door and AppKit execution context when traffic
+arrives through the platform. Use this package for a public tunnel or another
+route that bypasses that identity-aware proxy and therefore needs its own
+passwordless session. A passkey session proves the configured identity only; it
+does not mint a Databricks OBO access token.
+
+```ts
+import { auth, storage } from "@dbx-tools/auth-gate";
+
+const database = await storage.createAuthStorage({ storage: "sqlite" });
+const runtime = await auth.createPasswordlessAuth({
+  storage: database,
+  baseURL: "http://localhost:8000",
+  appName: "My app",
+  secret: process.env.AUTH_SECRET!,
+  logoutRedirectPath: "/",
+  sessionTtlSeconds: 2_592_000,
+  codeTtlSeconds: 600,
+  maxAttempts: 5,
+  authorizeIdentity: (email) => email.endsWith("@example.com"),
+  sendCode: async (email, code) => sendEmail(email, code),
+});
+```
+
+`POST <basePath>/logout` returns `{ ok, redirectTo }`; `GET` clears the same
+session and redirects with status `303`. The redirect defaults to `/` and is
+restricted to a same-origin path.
+
+## Modules
+
+- `auth` - Better Auth runtime and compatibility routes;
+- `storage` - Lakebase/SQLite selection and migration locking.

package/index.ts

@@ -0,0 +1,9 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+
+export const PACKAGE_IDENTIFIER = "@dbx-tools/auth-gate";
+export * as auth from "./src/auth.ts";
+export * as storage from "./src/storage.ts";
+export type { AuthorizeIdentity, AuthEmailOptions, PasswordlessAuthOptions, PasswordlessAuthRuntime } from "./src/auth.ts";
+export type { AuthStorageMode, AuthStorageConfig, ResolvedAuthStorageConfig, AuthDatabase, AuthStorage } from "./src/storage.ts";

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export declare const PACKAGE_IDENTIFIER = "@dbx-tools/auth-gate";
+export * as auth from "./src/auth.ts";
+export * as storage from "./src/storage.ts";
+export type { AuthorizeIdentity, AuthEmailOptions, PasswordlessAuthOptions, PasswordlessAuthRuntime } from "./src/auth.ts";
+export type { AuthStorageMode, AuthStorageConfig, ResolvedAuthStorageConfig, AuthDatabase, AuthStorage } from "./src/storage.ts";

package/lib/index.js

@@ -0,0 +1,7 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+export const PACKAGE_IDENTIFIER = "@dbx-tools/auth-gate";
+export * as auth from "./src/auth.js";
+export * as storage from "./src/storage.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxzQkFBc0IsQ0FBQztBQUN6RCxPQUFPLEtBQUssSUFBSSxNQUFNLGVBQWUsQ0FBQztBQUN0QyxPQUFPLEtBQUssT0FBTyxNQUFNLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR0VORVJBVEVEIGJ5IHByb2plbiB3YXRjaCAtIERPIE5PVCBFRElULlxuLy8gUmVnZW5lcmF0ZWQgZnJvbSB0aGUgZXhwb3J0aW5nIG1vZHVsZXMgaW4gLi9zcmMuXG4vLyBIYW5kIGVkaXRzIGFyZSBvdmVyd3JpdHRlbiBvbiB0aGUgbmV4dCB3YXRjaDsgdGhpcyBmaWxlIGlzIHJlYWQtb25seS5cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfSURFTlRJRklFUiA9IFwiQGRieC10b29scy9hdXRoLWdhdGVcIjtcbmV4cG9ydCAqIGFzIGF1dGggZnJvbSBcIi4vc3JjL2F1dGgudHNcIjtcbmV4cG9ydCAqIGFzIHN0b3JhZ2UgZnJvbSBcIi4vc3JjL3N0b3JhZ2UudHNcIjtcbmV4cG9ydCB0eXBlIHsgQXV0aG9yaXplSWRlbnRpdHksIEF1dGhFbWFpbE9wdGlvbnMsIFBhc3N3b3JkbGVzc0F1dGhPcHRpb25zLCBQYXNzd29yZGxlc3NBdXRoUnVudGltZSB9IGZyb20gXCIuL3NyYy9hdXRoLnRzXCI7XG5leHBvcnQgdHlwZSB7IEF1dGhTdG9yYWdlTW9kZSwgQXV0aFN0b3JhZ2VDb25maWcsIFJlc29sdmVkQXV0aFN0b3JhZ2VDb25maWcsIEF1dGhEYXRhYmFzZSwgQXV0aFN0b3JhZ2UgfSBmcm9tIFwiLi9zcmMvc3RvcmFnZS50c1wiO1xuIl19

package/lib/src/auth.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Better Auth passwordless runtime with email OTP and passkeys.
+ *
+ * Callers provide authorization, delivery, storage, origin, and secret. Better
+ * Auth owns users, OTP verification records, sessions, rate limits, passkey
+ * credentials, and their native HTTP routes.
+ *
+ * @module
+ */
+import { type AuthStatus } from "@dbx-tools/shared-auth";
+import type { AuthStorage } from "./storage.ts";
+export type AuthorizeIdentity = (email: string) => boolean | Promise<boolean>;
+export interface AuthEmailOptions {
+    subject: string;
+    brandName: string;
+    message: string;
+    codeTtlSeconds: number;
+}
+export interface PasswordlessAuthOptions {
+    storage: AuthStorage;
+    baseURL: string;
+    basePath?: string;
+    appName: string;
+    secret: string;
+    sessionCookieName?: string;
+    /** Same-origin path returned after logout. Defaults to `/`. */
+    logoutRedirectPath?: string;
+    sessionTtlSeconds: number;
+    sessionCutoffMs?: number;
+    codeTtlSeconds: number;
+    maxAttempts: number;
+    authorizeIdentity: AuthorizeIdentity;
+    sendCode(email: string, code: string, options: AuthEmailOptions): Promise<void>;
+    subject?: string;
+    message?: string;
+}
+export interface PasswordlessAuthRuntime {
+    readonly basePath: string;
+    readonly passkeysEnabled: boolean;
+    handler(request: Request): Promise<Response>;
+    session(headers: Headers): Promise<string | undefined>;
+    status(headers: Headers): Promise<AuthStatus>;
+    close(): Promise<void>;
+}
+export declare function createPasswordlessAuth(config: PasswordlessAuthOptions): Promise<PasswordlessAuthRuntime>;
+/** Restrict logout redirects to one same-origin application path. */
+export declare function normalizeLogoutRedirectPath(value: string | undefined): string;

package/lib/src/auth.js

@@ -0,0 +1,217 @@
+/**
+ * Better Auth passwordless runtime with email OTP and passkeys.
+ *
+ * Callers provide authorization, delivery, storage, origin, and secret. Better
+ * Auth owns users, OTP verification records, sessions, rate limits, passkey
+ * credentials, and their native HTTP routes.
+ *
+ * @module
+ */
+import { passkey } from "@better-auth/passkey";
+import { SESSION_COOKIE_NAME } from "@dbx-tools/shared-auth";
+import { log } from "@dbx-tools/shared-core";
+import { APIError, betterAuth } from "better-auth";
+import { emailOTP } from "better-auth/plugins";
+import { migrateAuth } from "./storage.js";
+const logger = log.logger("auth");
+export async function createPasswordlessAuth(config) {
+    const origin = new URL(config.baseURL).origin;
+    const rpID = new URL(origin).hostname;
+    const basePath = config.basePath ?? "/api/auth";
+    const logoutRedirectPath = normalizeLogoutRedirectPath(config.logoutRedirectPath);
+    const emailOptions = {
+        subject: config.subject ?? "Your verification code",
+        brandName: config.appName,
+        message: config.message ?? "Your verification code is:",
+        codeTtlSeconds: config.codeTtlSeconds,
+    };
+    const options = {
+        appName: config.appName,
+        baseURL: origin,
+        basePath,
+        database: config.storage.database,
+        secret: config.secret,
+        // The gate fronts the app on whatever interface address the tunnel binds
+        // (an overlay/LAN IP, localhost, or a public domain) — not just `baseURL`.
+        // Better Auth's origin check would reject every other host with
+        // INVALID_ORIGIN and block sign-in. Trust the request's own origin here:
+        // this endpoint sits behind the OTP gate and the tunnel preserves the
+        // browser's Host, so the fixed-origin CSRF check adds nothing while breaking
+        // legitimate access. Same-origin requests (no Origin header) are allowed too.
+        trustedOrigins: (request) => {
+            const requestOrigin = request?.headers.get("origin");
+            return requestOrigin ? [requestOrigin, origin] : [origin];
+        },
+        session: {
+            expiresIn: config.sessionTtlSeconds,
+            updateAge: Math.min(24 * 60 * 60, config.sessionTtlSeconds),
+        },
+        verification: {
+            storeIdentifier: "hashed",
+            storeInDatabase: true,
+        },
+        rateLimit: {
+            enabled: true,
+            window: 15 * 60,
+            max: 10,
+            customRules: {
+                "/email-otp/send-verification-otp": { window: 15 * 60, max: 5 },
+                "/sign-in/email-otp": { window: 15 * 60, max: 10 },
+            },
+        },
+        advanced: {
+            useSecureCookies: origin.startsWith("https://"),
+            ipAddress: {
+                ipAddressHeaders: ["x-real-ip"],
+                disableIpTracking: false,
+            },
+            cookies: {
+                session_token: {
+                    name: config.sessionCookieName ?? SESSION_COOKIE_NAME,
+                    attributes: {
+                        httpOnly: true,
+                        sameSite: "lax",
+                        secure: origin.startsWith("https://"),
+                        path: "/",
+                    },
+                },
+            },
+        },
+        databaseHooks: {
+            user: {
+                create: {
+                    before: async (user) => {
+                        if (!(await config.authorizeIdentity(normalizeEmail(user.email)))) {
+                            throw new APIError("FORBIDDEN", { message: "Identity is not authorized" });
+                        }
+                        return { data: user };
+                    },
+                },
+            },
+        },
+        plugins: [
+            emailOTP({
+                otpLength: 6,
+                expiresIn: config.codeTtlSeconds,
+                allowedAttempts: config.maxAttempts,
+                storeOTP: "hashed",
+                async sendVerificationOTP({ email, otp, type }) {
+                    if (type !== "sign-in")
+                        return;
+                    const address = normalizeEmail(email);
+                    if (!(await config.authorizeIdentity(address))) {
+                        // Accept any address and fail SILENTLY for one not on the allow-list:
+                        // the request still returns 200 (so the gate never reveals who is
+                        // allowed), and no code is sent. Logged at debug for diagnostics, not
+                        // as a warning — an unknown address hitting the login page is normal.
+                        logger.debug("verification code suppressed: identity not authorized", {
+                            email: address,
+                        });
+                        return;
+                    }
+                    logger.info("sending verification code", { email: address });
+                    void config.sendCode(address, otp, emailOptions).catch((error) => {
+                        logger.error("verification email failed", { email: address, error });
+                    });
+                },
+            }),
+            passkey({
+                rpID,
+                rpName: config.appName,
+                origin,
+                authenticatorSelection: {
+                    residentKey: "preferred",
+                    userVerification: "preferred",
+                },
+                registration: { requireSession: true },
+            }),
+        ],
+    };
+    await migrateAuth(options, config.storage);
+    const auth = betterAuth(options);
+    const session = async (headers) => {
+        const current = await auth.api.getSession({ headers });
+        const email = normalizeEmail(current?.user.email);
+        const createdAt = current?.session.createdAt;
+        const createdAtMs = createdAt ? new Date(createdAt).getTime() : Number.NaN;
+        if (config.sessionCutoffMs && !(createdAtMs >= config.sessionCutoffMs))
+            return undefined;
+        if (!email || !(await config.authorizeIdentity(email)))
+            return undefined;
+        return email;
+    };
+    const handleCompatibilityRoute = async (request) => {
+        const path = new URL(request.url).pathname;
+        if (path === `${basePath}/status`) {
+            const email = await session(request.headers);
+            return jsonResponse({
+                authenticated: Boolean(email),
+                ...(email ? { email } : {}),
+                enabled: true,
+                passkeysEnabled: true,
+            });
+        }
+        // OTP send + verify go straight to better-auth's native emailOTP endpoints
+        // (`/email-otp/send-verification-otp`, `/sign-in/email-otp`); there is no
+        // compatibility wrapper for them. Failures there are logged by the plugin's
+        // sendVerificationOTP hook, not swallowed behind an always-ok response.
+        if (path === `${basePath}/logout` && request.method === "POST") {
+            const response = await auth.api.signOut({
+                headers: request.headers,
+                asResponse: true,
+            });
+            return compatibilityResponse(response, { ok: response.ok, redirectTo: logoutRedirectPath });
+        }
+        if (path === `${basePath}/logout` && request.method === "GET") {
+            const response = await auth.api.signOut({
+                headers: request.headers,
+                asResponse: true,
+            });
+            return redirectResponse(response, logoutRedirectPath);
+        }
+        return undefined;
+    };
+    return {
+        basePath,
+        passkeysEnabled: true,
+        handler: async (request) => (await handleCompatibilityRoute(request)) ?? auth.handler(request),
+        session,
+        status: async (headers) => {
+            const email = await session(headers);
+            return {
+                authenticated: Boolean(email),
+                ...(email ? { email } : {}),
+                enabled: true,
+                passkeysEnabled: true,
+            };
+        },
+        close: () => config.storage.close(),
+    };
+}
+/** Restrict logout redirects to one same-origin application path. */
+export function normalizeLogoutRedirectPath(value) {
+    const path = value?.trim();
+    return path?.startsWith("/") && !path.startsWith("//") && !path.includes("\\") ? path : "/";
+}
+function normalizeEmail(email) {
+    return email?.trim().toLowerCase() ?? "";
+}
+function jsonResponse(body, status = 200) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { "content-type": "application/json" },
+    });
+}
+function compatibilityResponse(response, body) {
+    const headers = new Headers({ "content-type": "application/json" });
+    for (const cookie of response.headers.getSetCookie())
+        headers.append("set-cookie", cookie);
+    return new Response(JSON.stringify(body), { status: 200, headers });
+}
+function redirectResponse(response, location) {
+    const headers = new Headers({ location });
+    for (const cookie of response.headers.getSetCookie())
+        headers.append("set-cookie", cookie);
+    return new Response(null, { status: 303, headers });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/auth.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Better Auth passwordless runtime with email OTP and passkeys.\n *\n * Callers provide authorization, delivery, storage, origin, and secret. Better\n * Auth owns users, OTP verification records, sessions, rate limits, passkey\n * credentials, and their native HTTP routes.\n *\n * @module\n */\n\nimport { passkey } from \"@better-auth/passkey\";\nimport { type AuthStatus, SESSION_COOKIE_NAME } from \"@dbx-tools/shared-auth\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport { APIError, betterAuth, type BetterAuthOptions } from \"better-auth\";\nimport { emailOTP } from \"better-auth/plugins\";\n\nimport type { AuthStorage } from \"./storage.ts\";\nimport { migrateAuth } from \"./storage.ts\";\n\nconst logger = log.logger(\"auth\");\n\nexport type AuthorizeIdentity = (email: string) => boolean | Promise<boolean>;\n\nexport interface AuthEmailOptions {\n  subject: string;\n  brandName: string;\n  message: string;\n  codeTtlSeconds: number;\n}\n\nexport interface PasswordlessAuthOptions {\n  storage: AuthStorage;\n  baseURL: string;\n  basePath?: string;\n  appName: string;\n  secret: string;\n  sessionCookieName?: string;\n  /** Same-origin path returned after logout. Defaults to `/`. */\n  logoutRedirectPath?: string;\n  sessionTtlSeconds: number;\n  sessionCutoffMs?: number;\n  codeTtlSeconds: number;\n  maxAttempts: number;\n  authorizeIdentity: AuthorizeIdentity;\n  sendCode(email: string, code: string, options: AuthEmailOptions): Promise<void>;\n  subject?: string;\n  message?: string;\n}\n\nexport interface PasswordlessAuthRuntime {\n  readonly basePath: string;\n  readonly passkeysEnabled: boolean;\n  handler(request: Request): Promise<Response>;\n  session(headers: Headers): Promise<string | undefined>;\n  status(headers: Headers): Promise<AuthStatus>;\n  close(): Promise<void>;\n}\n\nexport async function createPasswordlessAuth(\n  config: PasswordlessAuthOptions,\n): Promise<PasswordlessAuthRuntime> {\n  const origin = new URL(config.baseURL).origin;\n  const rpID = new URL(origin).hostname;\n  const basePath = config.basePath ?? \"/api/auth\";\n  const logoutRedirectPath = normalizeLogoutRedirectPath(config.logoutRedirectPath);\n  const emailOptions: AuthEmailOptions = {\n    subject: config.subject ?? \"Your verification code\",\n    brandName: config.appName,\n    message: config.message ?? \"Your verification code is:\",\n    codeTtlSeconds: config.codeTtlSeconds,\n  };\n\n  const options = {\n    appName: config.appName,\n    baseURL: origin,\n    basePath,\n    database: config.storage.database,\n    secret: config.secret,\n    // The gate fronts the app on whatever interface address the tunnel binds\n    // (an overlay/LAN IP, localhost, or a public domain) — not just `baseURL`.\n    // Better Auth's origin check would reject every other host with\n    // INVALID_ORIGIN and block sign-in. Trust the request's own origin here:\n    // this endpoint sits behind the OTP gate and the tunnel preserves the\n    // browser's Host, so the fixed-origin CSRF check adds nothing while breaking\n    // legitimate access. Same-origin requests (no Origin header) are allowed too.\n    trustedOrigins: (request?: Request) => {\n      const requestOrigin = request?.headers.get(\"origin\");\n      return requestOrigin ? [requestOrigin, origin] : [origin];\n    },\n    session: {\n      expiresIn: config.sessionTtlSeconds,\n      updateAge: Math.min(24 * 60 * 60, config.sessionTtlSeconds),\n    },\n    verification: {\n      storeIdentifier: \"hashed\",\n      storeInDatabase: true,\n    },\n    rateLimit: {\n      enabled: true,\n      window: 15 * 60,\n      max: 10,\n      customRules: {\n        \"/email-otp/send-verification-otp\": { window: 15 * 60, max: 5 },\n        \"/sign-in/email-otp\": { window: 15 * 60, max: 10 },\n      },\n    },\n    advanced: {\n      useSecureCookies: origin.startsWith(\"https://\"),\n      ipAddress: {\n        ipAddressHeaders: [\"x-real-ip\"],\n        disableIpTracking: false,\n      },\n      cookies: {\n        session_token: {\n          name: config.sessionCookieName ?? SESSION_COOKIE_NAME,\n          attributes: {\n            httpOnly: true,\n            sameSite: \"lax\",\n            secure: origin.startsWith(\"https://\"),\n            path: \"/\",\n          },\n        },\n      },\n    },\n    databaseHooks: {\n      user: {\n        create: {\n          before: async (user: { email: string }) => {\n            if (!(await config.authorizeIdentity(normalizeEmail(user.email)))) {\n              throw new APIError(\"FORBIDDEN\", { message: \"Identity is not authorized\" });\n            }\n            return { data: user };\n          },\n        },\n      },\n    },\n    plugins: [\n      emailOTP({\n        otpLength: 6,\n        expiresIn: config.codeTtlSeconds,\n        allowedAttempts: config.maxAttempts,\n        storeOTP: \"hashed\",\n        async sendVerificationOTP({ email, otp, type }) {\n          if (type !== \"sign-in\") return;\n          const address = normalizeEmail(email);\n          if (!(await config.authorizeIdentity(address))) {\n            // Accept any address and fail SILENTLY for one not on the allow-list:\n            // the request still returns 200 (so the gate never reveals who is\n            // allowed), and no code is sent. Logged at debug for diagnostics, not\n            // as a warning — an unknown address hitting the login page is normal.\n            logger.debug(\"verification code suppressed: identity not authorized\", {\n              email: address,\n            });\n            return;\n          }\n          logger.info(\"sending verification code\", { email: address });\n          void config.sendCode(address, otp, emailOptions).catch((error: unknown) => {\n            logger.error(\"verification email failed\", { email: address, error });\n          });\n        },\n      }),\n      passkey({\n        rpID,\n        rpName: config.appName,\n        origin,\n        authenticatorSelection: {\n          residentKey: \"preferred\",\n          userVerification: \"preferred\",\n        },\n        registration: { requireSession: true },\n      }),\n    ] as const,\n  } satisfies BetterAuthOptions;\n\n  await migrateAuth(options, config.storage);\n  const auth = betterAuth(options);\n\n  const session = async (headers: Headers): Promise<string | undefined> => {\n    const current = await auth.api.getSession({ headers });\n    const email = normalizeEmail(current?.user.email);\n    const createdAt = current?.session.createdAt;\n    const createdAtMs = createdAt ? new Date(createdAt).getTime() : Number.NaN;\n    if (config.sessionCutoffMs && !(createdAtMs >= config.sessionCutoffMs)) return undefined;\n    if (!email || !(await config.authorizeIdentity(email))) return undefined;\n    return email;\n  };\n\n  const handleCompatibilityRoute = async (request: Request): Promise<Response | undefined> => {\n    const path = new URL(request.url).pathname;\n    if (path === `${basePath}/status`) {\n      const email = await session(request.headers);\n      return jsonResponse({\n        authenticated: Boolean(email),\n        ...(email ? { email } : {}),\n        enabled: true,\n        passkeysEnabled: true,\n      });\n    }\n    // OTP send + verify go straight to better-auth's native emailOTP endpoints\n    // (`/email-otp/send-verification-otp`, `/sign-in/email-otp`); there is no\n    // compatibility wrapper for them. Failures there are logged by the plugin's\n    // sendVerificationOTP hook, not swallowed behind an always-ok response.\n    if (path === `${basePath}/logout` && request.method === \"POST\") {\n      const response = await auth.api.signOut({\n        headers: request.headers,\n        asResponse: true,\n      });\n      return compatibilityResponse(response, { ok: response.ok, redirectTo: logoutRedirectPath });\n    }\n    if (path === `${basePath}/logout` && request.method === \"GET\") {\n      const response = await auth.api.signOut({\n        headers: request.headers,\n        asResponse: true,\n      });\n      return redirectResponse(response, logoutRedirectPath);\n    }\n    return undefined;\n  };\n\n  return {\n    basePath,\n    passkeysEnabled: true,\n    handler: async (request) => (await handleCompatibilityRoute(request)) ?? auth.handler(request),\n    session,\n    status: async (headers) => {\n      const email = await session(headers);\n      return {\n        authenticated: Boolean(email),\n        ...(email ? { email } : {}),\n        enabled: true,\n        passkeysEnabled: true,\n      };\n    },\n    close: () => config.storage.close(),\n  };\n}\n\n/** Restrict logout redirects to one same-origin application path. */\nexport function normalizeLogoutRedirectPath(value: string | undefined): string {\n  const path = value?.trim();\n  return path?.startsWith(\"/\") && !path.startsWith(\"//\") && !path.includes(\"\\\\\") ? path : \"/\";\n}\n\nfunction normalizeEmail(email: string | undefined): string {\n  return email?.trim().toLowerCase() ?? \"\";\n}\n\nfunction jsonResponse(body: unknown, status = 200): Response {\n  return new Response(JSON.stringify(body), {\n    status,\n    headers: { \"content-type\": \"application/json\" },\n  });\n}\n\nfunction compatibilityResponse(response: Response, body: unknown): Response {\n  const headers = new Headers({ \"content-type\": \"application/json\" });\n  for (const cookie of response.headers.getSetCookie()) headers.append(\"set-cookie\", cookie);\n  return new Response(JSON.stringify(body), { status: 200, headers });\n}\n\nfunction redirectResponse(response: Response, location: string): Response {\n  const headers = new Headers({ location });\n  for (const cookie of response.headers.getSetCookie()) headers.append(\"set-cookie\", cookie);\n  return new Response(null, { status: 303, headers });\n}\n"]}

package/lib/src/storage.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Better Auth database selection and migration locking.
+ *
+ * Callers pass a native AppKit Lakebase pool when available. Otherwise auth
+ * uses SQLite in the operating system's application-data directory.
+ *
+ * @module
+ */
+import { type PgPoolLike } from "@dbx-tools/postgres";
+import type { BetterAuthOptions } from "better-auth";
+export type AuthStorageMode = "auto" | "lakebase" | "sqlite";
+export interface AuthStorageConfig {
+    storage?: AuthStorageMode;
+    sqlitePath?: string;
+}
+export interface ResolvedAuthStorageConfig {
+    mode: AuthStorageMode;
+    sqlitePath: string;
+}
+export type AuthDatabase = NonNullable<BetterAuthOptions["database"]>;
+export interface AuthStorage {
+    kind: "lakebase" | "sqlite" | "memory";
+    database: AuthDatabase;
+    pool?: PgPoolLike;
+    path?: string;
+    close(): Promise<void>;
+}
+export declare function resolveAuthStorageConfig(config?: AuthStorageConfig): ResolvedAuthStorageConfig;
+export declare function shouldUseLakebase(config?: AuthStorageConfig): boolean;
+export declare function createAuthStorage(config: AuthStorageConfig, pool?: PgPoolLike): Promise<AuthStorage>;
+export declare function migrateAuth(options: BetterAuthOptions, storage: AuthStorage): Promise<void>;

package/lib/src/storage.js

@@ -0,0 +1,120 @@
+/**
+ * Better Auth database selection and migration locking.
+ *
+ * Callers pass a native AppKit Lakebase pool when available. Otherwise auth
+ * uses SQLite in the operating system's application-data directory.
+ *
+ * @module
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileLock } from "@dbx-tools/core";
+import { advisoryLock } from "@dbx-tools/postgres";
+import { log } from "@dbx-tools/shared-core";
+import envPaths from "env-paths";
+const logger = log.logger("auth:storage");
+const MIGRATION_LOCK = ["auth", "better-auth", "migrations"];
+export function resolveAuthStorageConfig(config = {}) {
+    const mode = config.storage ?? "auto";
+    if (mode !== "auto" && mode !== "lakebase" && mode !== "sqlite") {
+        throw new TypeError('auth storage must be "auto", "lakebase", or "sqlite"');
+    }
+    const dataDirectory = envPaths("dbx-tools", { suffix: "" }).data;
+    return {
+        mode,
+        sqlitePath: resolve(config.sqlitePath ?? resolve(dataDirectory, "auth", "auth.sqlite")),
+    };
+}
+export function shouldUseLakebase(config = {}) {
+    const resolved = resolveAuthStorageConfig(config);
+    if (resolved.mode === "lakebase")
+        return true;
+    if (resolved.mode === "sqlite")
+        return false;
+    return Boolean(process.env.LAKEBASE_ENDPOINT ?? process.env.PGHOST);
+}
+export async function createAuthStorage(config, pool) {
+    const resolved = resolveAuthStorageConfig(config);
+    if (pool && resolved.mode !== "sqlite") {
+        return {
+            kind: "lakebase",
+            database: pool,
+            pool,
+            close: async () => undefined,
+        };
+    }
+    if (resolved.mode === "lakebase") {
+        throw new Error("auth storage is lakebase but no Lakebase pool was supplied");
+    }
+    // Prefer SQLite (durable, survives restarts) when a SQLite binding is present
+    // — bun:sqlite in Bun, node:sqlite in Node. Both are optional runtime
+    // features, so fall back to an in-memory adapter when neither can be opened
+    // rather than failing the whole gate. Memory loses sessions/OTPs on restart
+    // but keeps sign-in working; an explicit `--auth-storage sqlite` still errors
+    // if SQLite is genuinely unavailable, so the fallback is auto-mode only.
+    try {
+        mkdirSync(dirname(resolved.sqlitePath), { recursive: true });
+        const database = await openSqlite(resolved.sqlitePath);
+        return {
+            kind: "sqlite",
+            database,
+            path: resolved.sqlitePath,
+            close: async () => {
+                database.close();
+            },
+        };
+    }
+    catch (error) {
+        if (resolved.mode === "sqlite")
+            throw error;
+        logger.warn("sqlite unavailable for auth storage; using in-memory adapter", { error });
+        const { memoryAdapter } = await import("better-auth/adapters/memory");
+        return {
+            kind: "memory",
+            database: memoryAdapter({}),
+            close: async () => undefined,
+        };
+    }
+}
+export async function migrateAuth(options, storage) {
+    // The in-memory adapter builds its schema in memory on init — there is no
+    // database to migrate.
+    if (storage.kind === "memory")
+        return;
+    const run = async () => {
+        const module = (await import(__rewriteRelativeImportExtension(migrationModuleUrl())));
+        const migrations = await module.getMigrations(options);
+        await migrations.runMigrations();
+    };
+    if (storage.kind === "lakebase" && storage.pool) {
+        await advisoryLock.withAdvisoryLock(storage.pool, MIGRATION_LOCK, run);
+        return;
+    }
+    await fileLock.withFileLock(MIGRATION_LOCK, run);
+}
+async function openSqlite(path) {
+    if (process.versions.bun) {
+        const specifier = "bun:sqlite";
+        const { Database } = (await import(__rewriteRelativeImportExtension(specifier)));
+        const database = new Database(path, { create: true, strict: true });
+        database.exec("PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON");
+        return database;
+    }
+    const { DatabaseSync } = await import("node:sqlite");
+    const database = new DatabaseSync(path);
+    database.exec("PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON");
+    return database;
+}
+function migrationModuleUrl() {
+    const entry = import.meta.resolve("better-auth");
+    return new URL("./db/get-migration.mjs", entry).href;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../src/storage.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Better Auth database selection and migration locking.\n *\n * Callers pass a native AppKit Lakebase pool when available. Otherwise auth\n * uses SQLite in the operating system's application-data directory.\n *\n * @module\n */\n\nimport { mkdirSync } from \"node:fs\";\nimport { dirname, resolve } from \"node:path\";\nimport { fileLock } from \"@dbx-tools/core\";\nimport { advisoryLock, type PgPoolLike } from \"@dbx-tools/postgres\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport type { BetterAuthOptions } from \"better-auth\";\nimport envPaths from \"env-paths\";\n\nconst logger = log.logger(\"auth:storage\");\n\nexport type AuthStorageMode = \"auto\" | \"lakebase\" | \"sqlite\";\n\nexport interface AuthStorageConfig {\n  storage?: AuthStorageMode;\n  sqlitePath?: string;\n}\n\nexport interface ResolvedAuthStorageConfig {\n  mode: AuthStorageMode;\n  sqlitePath: string;\n}\n\nexport type AuthDatabase = NonNullable<BetterAuthOptions[\"database\"]>;\n\nexport interface AuthStorage {\n  kind: \"lakebase\" | \"sqlite\" | \"memory\";\n  database: AuthDatabase;\n  pool?: PgPoolLike;\n  path?: string;\n  close(): Promise<void>;\n}\n\ntype MigrationModule = {\n  getMigrations(options: BetterAuthOptions): Promise<{\n    runMigrations(): Promise<void>;\n  }>;\n};\n\ninterface SqliteDatabase {\n  exec(sql: string): unknown;\n  close(): void;\n}\n\ninterface BunSqliteModule {\n  Database: new (path: string, options?: { create?: boolean; strict?: boolean }) => SqliteDatabase;\n}\n\nconst MIGRATION_LOCK = [\"auth\", \"better-auth\", \"migrations\"] as const;\n\nexport function resolveAuthStorageConfig(\n  config: AuthStorageConfig = {},\n): ResolvedAuthStorageConfig {\n  const mode = config.storage ?? \"auto\";\n  if (mode !== \"auto\" && mode !== \"lakebase\" && mode !== \"sqlite\") {\n    throw new TypeError('auth storage must be \"auto\", \"lakebase\", or \"sqlite\"');\n  }\n  const dataDirectory = envPaths(\"dbx-tools\", { suffix: \"\" }).data;\n  return {\n    mode,\n    sqlitePath: resolve(config.sqlitePath ?? resolve(dataDirectory, \"auth\", \"auth.sqlite\")),\n  };\n}\n\nexport function shouldUseLakebase(config: AuthStorageConfig = {}): boolean {\n  const resolved = resolveAuthStorageConfig(config);\n  if (resolved.mode === \"lakebase\") return true;\n  if (resolved.mode === \"sqlite\") return false;\n  return Boolean(process.env.LAKEBASE_ENDPOINT ?? process.env.PGHOST);\n}\n\nexport async function createAuthStorage(\n  config: AuthStorageConfig,\n  pool?: PgPoolLike,\n): Promise<AuthStorage> {\n  const resolved = resolveAuthStorageConfig(config);\n  if (pool && resolved.mode !== \"sqlite\") {\n    return {\n      kind: \"lakebase\",\n      database: pool,\n      pool,\n      close: async () => undefined,\n    };\n  }\n  if (resolved.mode === \"lakebase\") {\n    throw new Error(\"auth storage is lakebase but no Lakebase pool was supplied\");\n  }\n\n  // Prefer SQLite (durable, survives restarts) when a SQLite binding is present\n  // — bun:sqlite in Bun, node:sqlite in Node. Both are optional runtime\n  // features, so fall back to an in-memory adapter when neither can be opened\n  // rather than failing the whole gate. Memory loses sessions/OTPs on restart\n  // but keeps sign-in working; an explicit `--auth-storage sqlite` still errors\n  // if SQLite is genuinely unavailable, so the fallback is auto-mode only.\n  try {\n    mkdirSync(dirname(resolved.sqlitePath), { recursive: true });\n    const database = await openSqlite(resolved.sqlitePath);\n    return {\n      kind: \"sqlite\",\n      database,\n      path: resolved.sqlitePath,\n      close: async () => {\n        database.close();\n      },\n    };\n  } catch (error) {\n    if (resolved.mode === \"sqlite\") throw error;\n    logger.warn(\"sqlite unavailable for auth storage; using in-memory adapter\", { error });\n    const { memoryAdapter } = await import(\"better-auth/adapters/memory\");\n    return {\n      kind: \"memory\",\n      database: memoryAdapter({}) as unknown as AuthDatabase,\n      close: async () => undefined,\n    };\n  }\n}\n\nexport async function migrateAuth(options: BetterAuthOptions, storage: AuthStorage): Promise<void> {\n  // The in-memory adapter builds its schema in memory on init — there is no\n  // database to migrate.\n  if (storage.kind === \"memory\") return;\n\n  const run = async (): Promise<void> => {\n    const module = (await import(migrationModuleUrl())) as MigrationModule;\n    const migrations = await module.getMigrations(options);\n    await migrations.runMigrations();\n  };\n\n  if (storage.kind === \"lakebase\" && storage.pool) {\n    await advisoryLock.withAdvisoryLock(storage.pool, MIGRATION_LOCK, run);\n    return;\n  }\n  await fileLock.withFileLock(MIGRATION_LOCK, run);\n}\n\nasync function openSqlite(path: string): Promise<AuthDatabase & { close(): void }> {\n  if (process.versions.bun) {\n    const specifier = \"bun:sqlite\";\n    const { Database } = (await import(specifier)) as BunSqliteModule;\n    const database = new Database(path, { create: true, strict: true });\n    database.exec(\"PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON\");\n    return database;\n  }\n  const { DatabaseSync } = await import(\"node:sqlite\");\n  const database = new DatabaseSync(path);\n  database.exec(\"PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON\");\n  return database;\n}\n\nfunction migrationModuleUrl(): string {\n  const entry = import.meta.resolve(\"better-auth\");\n  return new URL(\"./db/get-migration.mjs\", entry).href;\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/auth.ts","../src/storage.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@dbx-tools/auth-gate",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reggie-db/dbx-tools.git",
+    "directory": "packages/js/node/auth-gate"
+  },
+  "scripts": {
+    "build": "projen build",
+    "compile": "projen compile",
+    "default": "projen default",
+    "package": "projen package",
+    "post-compile": "projen post-compile",
+    "pre-compile": "projen pre-compile",
+    "prepack": "projen prepack",
+    "test": "projen test",
+    "watch": "projen watch",
+    "projen": "projen"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.14",
+    "@types/node": "^24.6.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@better-auth/passkey": "^1.6.25",
+    "@dbx-tools/core": "0.6.168",
+    "@dbx-tools/postgres": "0.6.168",
+    "@dbx-tools/shared-auth": "0.6.168",
+    "@dbx-tools/shared-core": "0.6.168",
+    "better-auth": "^1.6.25",
+    "env-paths": "^4.0.0"
+  },
+  "main": "./lib/index.js",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public",
+    "main": "./lib/index.js",
+    "types": "./lib/index.d.ts",
+    "exports": {
+      ".": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      },
+      "./package.json": "./package.json"
+    }
+  },
+  "version": "0.6.168",
+  "types": "./lib/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.ts",
+    "src",
+    "lib"
+  ],
+  "dbxToolsConfig": {
+    "tags": [
+      "node"
+    ]
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"bunx projen\"."
+}

package/src/auth.ts

@@ -0,0 +1,265 @@
+/**
+ * Better Auth passwordless runtime with email OTP and passkeys.
+ *
+ * Callers provide authorization, delivery, storage, origin, and secret. Better
+ * Auth owns users, OTP verification records, sessions, rate limits, passkey
+ * credentials, and their native HTTP routes.
+ *
+ * @module
+ */
+
+import { passkey } from "@better-auth/passkey";
+import { type AuthStatus, SESSION_COOKIE_NAME } from "@dbx-tools/shared-auth";
+import { log } from "@dbx-tools/shared-core";
+import { APIError, betterAuth, type BetterAuthOptions } from "better-auth";
+import { emailOTP } from "better-auth/plugins";
+
+import type { AuthStorage } from "./storage.ts";
+import { migrateAuth } from "./storage.ts";
+
+const logger = log.logger("auth");
+
+export type AuthorizeIdentity = (email: string) => boolean | Promise<boolean>;
+
+export interface AuthEmailOptions {
+  subject: string;
+  brandName: string;
+  message: string;
+  codeTtlSeconds: number;
+}
+
+export interface PasswordlessAuthOptions {
+  storage: AuthStorage;
+  baseURL: string;
+  basePath?: string;
+  appName: string;
+  secret: string;
+  sessionCookieName?: string;
+  /** Same-origin path returned after logout. Defaults to `/`. */
+  logoutRedirectPath?: string;
+  sessionTtlSeconds: number;
+  sessionCutoffMs?: number;
+  codeTtlSeconds: number;
+  maxAttempts: number;
+  authorizeIdentity: AuthorizeIdentity;
+  sendCode(email: string, code: string, options: AuthEmailOptions): Promise<void>;
+  subject?: string;
+  message?: string;
+}
+
+export interface PasswordlessAuthRuntime {
+  readonly basePath: string;
+  readonly passkeysEnabled: boolean;
+  handler(request: Request): Promise<Response>;
+  session(headers: Headers): Promise<string | undefined>;
+  status(headers: Headers): Promise<AuthStatus>;
+  close(): Promise<void>;
+}
+
+export async function createPasswordlessAuth(
+  config: PasswordlessAuthOptions,
+): Promise<PasswordlessAuthRuntime> {
+  const origin = new URL(config.baseURL).origin;
+  const rpID = new URL(origin).hostname;
+  const basePath = config.basePath ?? "/api/auth";
+  const logoutRedirectPath = normalizeLogoutRedirectPath(config.logoutRedirectPath);
+  const emailOptions: AuthEmailOptions = {
+    subject: config.subject ?? "Your verification code",
+    brandName: config.appName,
+    message: config.message ?? "Your verification code is:",
+    codeTtlSeconds: config.codeTtlSeconds,
+  };
+
+  const options = {
+    appName: config.appName,
+    baseURL: origin,
+    basePath,
+    database: config.storage.database,
+    secret: config.secret,
+    // The gate fronts the app on whatever interface address the tunnel binds
+    // (an overlay/LAN IP, localhost, or a public domain) — not just `baseURL`.
+    // Better Auth's origin check would reject every other host with
+    // INVALID_ORIGIN and block sign-in. Trust the request's own origin here:
+    // this endpoint sits behind the OTP gate and the tunnel preserves the
+    // browser's Host, so the fixed-origin CSRF check adds nothing while breaking
+    // legitimate access. Same-origin requests (no Origin header) are allowed too.
+    trustedOrigins: (request?: Request) => {
+      const requestOrigin = request?.headers.get("origin");
+      return requestOrigin ? [requestOrigin, origin] : [origin];
+    },
+    session: {
+      expiresIn: config.sessionTtlSeconds,
+      updateAge: Math.min(24 * 60 * 60, config.sessionTtlSeconds),
+    },
+    verification: {
+      storeIdentifier: "hashed",
+      storeInDatabase: true,
+    },
+    rateLimit: {
+      enabled: true,
+      window: 15 * 60,
+      max: 10,
+      customRules: {
+        "/email-otp/send-verification-otp": { window: 15 * 60, max: 5 },
+        "/sign-in/email-otp": { window: 15 * 60, max: 10 },
+      },
+    },
+    advanced: {
+      useSecureCookies: origin.startsWith("https://"),
+      ipAddress: {
+        ipAddressHeaders: ["x-real-ip"],
+        disableIpTracking: false,
+      },
+      cookies: {
+        session_token: {
+          name: config.sessionCookieName ?? SESSION_COOKIE_NAME,
+          attributes: {
+            httpOnly: true,
+            sameSite: "lax",
+            secure: origin.startsWith("https://"),
+            path: "/",
+          },
+        },
+      },
+    },
+    databaseHooks: {
+      user: {
+        create: {
+          before: async (user: { email: string }) => {
+            if (!(await config.authorizeIdentity(normalizeEmail(user.email)))) {
+              throw new APIError("FORBIDDEN", { message: "Identity is not authorized" });
+            }
+            return { data: user };
+          },
+        },
+      },
+    },
+    plugins: [
+      emailOTP({
+        otpLength: 6,
+        expiresIn: config.codeTtlSeconds,
+        allowedAttempts: config.maxAttempts,
+        storeOTP: "hashed",
+        async sendVerificationOTP({ email, otp, type }) {
+          if (type !== "sign-in") return;
+          const address = normalizeEmail(email);
+          if (!(await config.authorizeIdentity(address))) {
+            // Accept any address and fail SILENTLY for one not on the allow-list:
+            // the request still returns 200 (so the gate never reveals who is
+            // allowed), and no code is sent. Logged at debug for diagnostics, not
+            // as a warning — an unknown address hitting the login page is normal.
+            logger.debug("verification code suppressed: identity not authorized", {
+              email: address,
+            });
+            return;
+          }
+          logger.info("sending verification code", { email: address });
+          void config.sendCode(address, otp, emailOptions).catch((error: unknown) => {
+            logger.error("verification email failed", { email: address, error });
+          });
+        },
+      }),
+      passkey({
+        rpID,
+        rpName: config.appName,
+        origin,
+        authenticatorSelection: {
+          residentKey: "preferred",
+          userVerification: "preferred",
+        },
+        registration: { requireSession: true },
+      }),
+    ] as const,
+  } satisfies BetterAuthOptions;
+
+  await migrateAuth(options, config.storage);
+  const auth = betterAuth(options);
+
+  const session = async (headers: Headers): Promise<string | undefined> => {
+    const current = await auth.api.getSession({ headers });
+    const email = normalizeEmail(current?.user.email);
+    const createdAt = current?.session.createdAt;
+    const createdAtMs = createdAt ? new Date(createdAt).getTime() : Number.NaN;
+    if (config.sessionCutoffMs && !(createdAtMs >= config.sessionCutoffMs)) return undefined;
+    if (!email || !(await config.authorizeIdentity(email))) return undefined;
+    return email;
+  };
+
+  const handleCompatibilityRoute = async (request: Request): Promise<Response | undefined> => {
+    const path = new URL(request.url).pathname;
+    if (path === `${basePath}/status`) {
+      const email = await session(request.headers);
+      return jsonResponse({
+        authenticated: Boolean(email),
+        ...(email ? { email } : {}),
+        enabled: true,
+        passkeysEnabled: true,
+      });
+    }
+    // OTP send + verify go straight to better-auth's native emailOTP endpoints
+    // (`/email-otp/send-verification-otp`, `/sign-in/email-otp`); there is no
+    // compatibility wrapper for them. Failures there are logged by the plugin's
+    // sendVerificationOTP hook, not swallowed behind an always-ok response.
+    if (path === `${basePath}/logout` && request.method === "POST") {
+      const response = await auth.api.signOut({
+        headers: request.headers,
+        asResponse: true,
+      });
+      return compatibilityResponse(response, { ok: response.ok, redirectTo: logoutRedirectPath });
+    }
+    if (path === `${basePath}/logout` && request.method === "GET") {
+      const response = await auth.api.signOut({
+        headers: request.headers,
+        asResponse: true,
+      });
+      return redirectResponse(response, logoutRedirectPath);
+    }
+    return undefined;
+  };
+
+  return {
+    basePath,
+    passkeysEnabled: true,
+    handler: async (request) => (await handleCompatibilityRoute(request)) ?? auth.handler(request),
+    session,
+    status: async (headers) => {
+      const email = await session(headers);
+      return {
+        authenticated: Boolean(email),
+        ...(email ? { email } : {}),
+        enabled: true,
+        passkeysEnabled: true,
+      };
+    },
+    close: () => config.storage.close(),
+  };
+}
+
+/** Restrict logout redirects to one same-origin application path. */
+export function normalizeLogoutRedirectPath(value: string | undefined): string {
+  const path = value?.trim();
+  return path?.startsWith("/") && !path.startsWith("//") && !path.includes("\\") ? path : "/";
+}
+
+function normalizeEmail(email: string | undefined): string {
+  return email?.trim().toLowerCase() ?? "";
+}
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+function compatibilityResponse(response: Response, body: unknown): Response {
+  const headers = new Headers({ "content-type": "application/json" });
+  for (const cookie of response.headers.getSetCookie()) headers.append("set-cookie", cookie);
+  return new Response(JSON.stringify(body), { status: 200, headers });
+}
+
+function redirectResponse(response: Response, location: string): Response {
+  const headers = new Headers({ location });
+  for (const cookie of response.headers.getSetCookie()) headers.append("set-cookie", cookie);
+  return new Response(null, { status: 303, headers });
+}

package/src/storage.ts

@@ -0,0 +1,161 @@
+/**
+ * Better Auth database selection and migration locking.
+ *
+ * Callers pass a native AppKit Lakebase pool when available. Otherwise auth
+ * uses SQLite in the operating system's application-data directory.
+ *
+ * @module
+ */
+
+import { mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileLock } from "@dbx-tools/core";
+import { advisoryLock, type PgPoolLike } from "@dbx-tools/postgres";
+import { log } from "@dbx-tools/shared-core";
+import type { BetterAuthOptions } from "better-auth";
+import envPaths from "env-paths";
+
+const logger = log.logger("auth:storage");
+
+export type AuthStorageMode = "auto" | "lakebase" | "sqlite";
+
+export interface AuthStorageConfig {
+  storage?: AuthStorageMode;
+  sqlitePath?: string;
+}
+
+export interface ResolvedAuthStorageConfig {
+  mode: AuthStorageMode;
+  sqlitePath: string;
+}
+
+export type AuthDatabase = NonNullable<BetterAuthOptions["database"]>;
+
+export interface AuthStorage {
+  kind: "lakebase" | "sqlite" | "memory";
+  database: AuthDatabase;
+  pool?: PgPoolLike;
+  path?: string;
+  close(): Promise<void>;
+}
+
+type MigrationModule = {
+  getMigrations(options: BetterAuthOptions): Promise<{
+    runMigrations(): Promise<void>;
+  }>;
+};
+
+interface SqliteDatabase {
+  exec(sql: string): unknown;
+  close(): void;
+}
+
+interface BunSqliteModule {
+  Database: new (path: string, options?: { create?: boolean; strict?: boolean }) => SqliteDatabase;
+}
+
+const MIGRATION_LOCK = ["auth", "better-auth", "migrations"] as const;
+
+export function resolveAuthStorageConfig(
+  config: AuthStorageConfig = {},
+): ResolvedAuthStorageConfig {
+  const mode = config.storage ?? "auto";
+  if (mode !== "auto" && mode !== "lakebase" && mode !== "sqlite") {
+    throw new TypeError('auth storage must be "auto", "lakebase", or "sqlite"');
+  }
+  const dataDirectory = envPaths("dbx-tools", { suffix: "" }).data;
+  return {
+    mode,
+    sqlitePath: resolve(config.sqlitePath ?? resolve(dataDirectory, "auth", "auth.sqlite")),
+  };
+}
+
+export function shouldUseLakebase(config: AuthStorageConfig = {}): boolean {
+  const resolved = resolveAuthStorageConfig(config);
+  if (resolved.mode === "lakebase") return true;
+  if (resolved.mode === "sqlite") return false;
+  return Boolean(process.env.LAKEBASE_ENDPOINT ?? process.env.PGHOST);
+}
+
+export async function createAuthStorage(
+  config: AuthStorageConfig,
+  pool?: PgPoolLike,
+): Promise<AuthStorage> {
+  const resolved = resolveAuthStorageConfig(config);
+  if (pool && resolved.mode !== "sqlite") {
+    return {
+      kind: "lakebase",
+      database: pool,
+      pool,
+      close: async () => undefined,
+    };
+  }
+  if (resolved.mode === "lakebase") {
+    throw new Error("auth storage is lakebase but no Lakebase pool was supplied");
+  }
+
+  // Prefer SQLite (durable, survives restarts) when a SQLite binding is present
+  // — bun:sqlite in Bun, node:sqlite in Node. Both are optional runtime
+  // features, so fall back to an in-memory adapter when neither can be opened
+  // rather than failing the whole gate. Memory loses sessions/OTPs on restart
+  // but keeps sign-in working; an explicit `--auth-storage sqlite` still errors
+  // if SQLite is genuinely unavailable, so the fallback is auto-mode only.
+  try {
+    mkdirSync(dirname(resolved.sqlitePath), { recursive: true });
+    const database = await openSqlite(resolved.sqlitePath);
+    return {
+      kind: "sqlite",
+      database,
+      path: resolved.sqlitePath,
+      close: async () => {
+        database.close();
+      },
+    };
+  } catch (error) {
+    if (resolved.mode === "sqlite") throw error;
+    logger.warn("sqlite unavailable for auth storage; using in-memory adapter", { error });
+    const { memoryAdapter } = await import("better-auth/adapters/memory");
+    return {
+      kind: "memory",
+      database: memoryAdapter({}) as unknown as AuthDatabase,
+      close: async () => undefined,
+    };
+  }
+}
+
+export async function migrateAuth(options: BetterAuthOptions, storage: AuthStorage): Promise<void> {
+  // The in-memory adapter builds its schema in memory on init — there is no
+  // database to migrate.
+  if (storage.kind === "memory") return;
+
+  const run = async (): Promise<void> => {
+    const module = (await import(migrationModuleUrl())) as MigrationModule;
+    const migrations = await module.getMigrations(options);
+    await migrations.runMigrations();
+  };
+
+  if (storage.kind === "lakebase" && storage.pool) {
+    await advisoryLock.withAdvisoryLock(storage.pool, MIGRATION_LOCK, run);
+    return;
+  }
+  await fileLock.withFileLock(MIGRATION_LOCK, run);
+}
+
+async function openSqlite(path: string): Promise<AuthDatabase & { close(): void }> {
+  if (process.versions.bun) {
+    const specifier = "bun:sqlite";
+    const { Database } = (await import(specifier)) as BunSqliteModule;
+    const database = new Database(path, { create: true, strict: true });
+    database.exec("PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON");
+    return database;
+  }
+  const { DatabaseSync } = await import("node:sqlite");
+  const database = new DatabaseSync(path);
+  database.exec("PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON");
+  return database;
+}
+
+function migrationModuleUrl(): string {
+  const entry = import.meta.resolve("better-auth");
+  return new URL("./db/get-migration.mjs", entry).href;
+}