@remit/mcp-server 0.0.0-stage → 0.1.1

package/dist/auth/authorization-server.js

@@ -0,0 +1,592 @@
+import { DEVICE_CODE_GRANT_TYPE, getOAuthProviderApi, oauthDeviceAuthorization, oauthProvider, oauthProviderAuthServerMetadata, } from "@better-auth/oauth-provider";
+import { ACCOUNT_DISABLED, CLIENT_IP_HEADER, SIGN_IN_DISABLED, } from "@remit/auth-service/constants";
+import { betterAuth, } from "better-auth";
+import { APIError, createAuthEndpoint, createAuthMiddleware, getSessionFromCtx, isAPIError, sessionMiddleware, } from "better-auth/api";
+import { setSessionCookie } from "better-auth/cookies";
+import { jwt } from "better-auth/plugins";
+import { z } from "zod";
+import { MCP_SCOPES, OFFLINE_ACCESS_SCOPE } from "./scopes.js";
+export const AUTH_BASE_PATH = "/auth";
+export const LOGIN_PATH = "/login";
+export const CONSENT_PATH = "/consent";
+export const DEVICE_PATH = "/device";
+export const CONNECTED_APPS_PATH = "/apps";
+export const MCP_PATH = "/mcp";
+export const SIGN_IN_PATH = "/mcp/sign-in";
+export const CONNECTED_APPS_API_PATH = "/mcp/connected-apps";
+export const REVOKE_CLIENT_API_PATH = "/mcp/revoke-client";
+export const JWKS_PATH = "/jwks";
+export const OAUTH2_PATH_PREFIX = "/oauth2/";
+export const DEVICE_CODE_PATH = "/device/code";
+export const DEVICE_APPROVE_PATH = "/device/approve";
+export const DEVICE_DENY_PATH = "/device/deny";
+export const ALLOWED_REDIRECT_URIS = [
+    "https://claude.ai/api/mcp/auth_callback",
+    "https://claude.com/api/mcp/auth_callback",
+];
+export const DEVICE_TOKEN_TTL_SECONDS = 90 * 24 * 60 * 60;
+export const BROWSER_TOKEN_TTL_SECONDS = 60 * 60;
+const LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "[::1]"]);
+export const isAllowedRedirectUri = (uri) => {
+    if (ALLOWED_REDIRECT_URIS.includes(uri))
+        return true;
+    if (!URL.canParse(uri))
+        return false;
+    const url = new URL(uri);
+    return (url.protocol === "http:" &&
+        LOOPBACK_HOSTS.has(url.hostname) &&
+        url.username === "" &&
+        url.password === "" &&
+        url.hash === "");
+};
+export const mcpResource = (origin) => `${origin}${MCP_PATH}`;
+const modelNames = {
+    oauthClient: { modelName: "mcp_oauth_client" },
+    oauthResource: { modelName: "mcp_oauth_resource" },
+    oauthClientResource: { modelName: "mcp_oauth_client_resource" },
+    oauthRefreshToken: { modelName: "mcp_oauth_refresh_token" },
+    oauthAccessToken: { modelName: "mcp_oauth_access_token" },
+    oauthConsent: { modelName: "mcp_oauth_consent" },
+    oauthClientAssertion: { modelName: "mcp_oauth_client_assertion" },
+};
+const buildOAuthOptions = (origin) => {
+    const resource = mcpResource(origin);
+    return {
+        schema: modelNames,
+        scopes: [...MCP_SCOPES, OFFLINE_ACCESS_SCOPE],
+        grantTypes: ["authorization_code", "refresh_token"],
+        // A refreshable token stays short; the device flow, which a static
+        // header carries and nothing refreshes, gets the long default. Every
+        // browser authorization is made refreshable by the authorize hook.
+        accessTokenExpiresIn: DEVICE_TOKEN_TTL_SECONDS,
+        scopeExpirations: {
+            [OFFLINE_ACCESS_SCOPE]: `${BROWSER_TOKEN_TTL_SECONDS}s`,
+        },
+        loginPage: `${origin}${LOGIN_PATH}`,
+        consentPage: `${origin}${CONSENT_PATH}`,
+        allowDynamicClientRegistration: true,
+        allowUnauthenticatedClientRegistration: true,
+        clientRegistrationDefaultApplicationType: "infer",
+        resources: [{ identifier: resource, name: "remit mail" }],
+        clientRegistrationDefaultResources: [resource],
+    };
+};
+const redirectUrisOf = (body) => {
+    if (typeof body !== "object" || body === null)
+        return [];
+    const uris = body.redirect_uris;
+    return Array.isArray(uris) ? uris : [];
+};
+const grantTypesOf = (body) => {
+    if (typeof body !== "object" || body === null)
+        return [];
+    const grantTypes = body.grant_types;
+    return Array.isArray(grantTypes) ? grantTypes : [];
+};
+const isDeviceOnlyClient = (body) => {
+    const grantTypes = grantTypesOf(body);
+    return (grantTypes.includes(DEVICE_CODE_GRANT_TYPE) &&
+        !grantTypes.includes("authorization_code"));
+};
+const withOfflineAccess = (query) => {
+    if (typeof query.scope !== "string")
+        return query;
+    const scopes = query.scope.split(" ").filter((scope) => scope.length > 0);
+    if (scopes.includes(OFFLINE_ACCESS_SCOPE))
+        return query;
+    return { ...query, scope: [...scopes, OFFLINE_ACCESS_SCOPE].join(" ") };
+};
+const userCodeOf = (body) => {
+    if (typeof body !== "object" || body === null)
+        return undefined;
+    const userCode = body.userCode;
+    return typeof userCode === "string" ? userCode : undefined;
+};
+const deviceCodeOf = async (ctx, userCode) => {
+    const find = (value) => ctx.context.adapter.findOne({
+        model: "deviceCode",
+        where: [{ field: "userCode", value }],
+    });
+    return ((await find(userCode)) ??
+        (await find(userCode.replace(/[^a-zA-Z0-9]/g, "").toUpperCase())));
+};
+const hasResource = (fields) => typeof fields === "object" &&
+    fields !== null &&
+    fields.resource !== undefined;
+const grantOf = (userId, clientId) => [
+    { field: "userId", value: userId },
+    { field: "clientId", value: clientId },
+];
+const refuseDisabled = async (identity, userId, headers) => {
+    if (!(await identity.isDisabled(userId)))
+        return;
+    await identity.audit({
+        actor: userId,
+        target: userId,
+        action: "SignInRefusedDisabled",
+        outcome: "RefusedDisabled",
+        clientIp: headers?.get(CLIENT_IP_HEADER) ?? "unknown",
+    });
+    throw new APIError("FORBIDDEN", { ...ACCOUNT_DISABLED });
+};
+const signInEndpoint = (signIn, identity) => createAuthEndpoint(SIGN_IN_PATH, {
+    method: "POST",
+    body: z.object({
+        email: z.string(),
+        password: z.string(),
+        oauth_query: z.string(),
+    }),
+}, async (ctx) => {
+    const result = await signIn(ctx.body.email, ctx.body.password);
+    if (!result.ok) {
+        throw new APIError("UNAUTHORIZED", {
+            message: "Invalid email or password",
+        });
+    }
+    await refuseDisabled(identity, result.userId, ctx.request?.headers);
+    const user = await ctx.context.internalAdapter.findUserById(result.userId);
+    if (!user) {
+        throw new APIError("UNAUTHORIZED", {
+            message: "Invalid email or password",
+        });
+    }
+    const session = await ctx.context.internalAdapter.createSession(user.id);
+    await setSessionCookie(ctx, { session, user });
+    return ctx.json({ redirect: false });
+});
+const isAlwaysServed = (path) => path === JWKS_PATH || path.startsWith("/.well-known/");
+const BROWSER_PATHS = new Set([
+    "/oauth2/authorize",
+    "/oauth2/consent",
+    "/oauth2/public-client",
+    DEVICE_APPROVE_PATH,
+    DEVICE_DENY_PATH,
+    CONNECTED_APPS_API_PATH,
+    REVOKE_CLIENT_API_PATH,
+]);
+const subjectSession = (subjectOf, identity) => ({
+    matcher: (ctx) => BROWSER_PATHS.has(ctx.path ?? ""),
+    handler: createAuthMiddleware(async (ctx) => {
+        const subject = await subjectOf(ctx.headers ?? new Headers());
+        if (!subject) {
+            throw new APIError("UNAUTHORIZED", {
+                message: "The host named no signed-in user",
+            });
+        }
+        await refuseDisabled(identity, subject.id, ctx.headers);
+        const { adapter, internalAdapter } = ctx.context;
+        const now = new Date();
+        const user = (await internalAdapter.findUserById(subject.id)) ??
+            (await adapter.create({
+                model: "user",
+                data: {
+                    id: subject.id,
+                    email: `${subject.id}@subject.invalid`,
+                    name: subject.id,
+                    emailVerified: true,
+                    createdAt: now,
+                    updatedAt: now,
+                },
+                forceAllowId: true,
+            }));
+        const live = (await internalAdapter.listSessions(user.id)).find((session) => session.expiresAt > now);
+        const session = live ?? (await internalAdapter.createSession(user.id));
+        ctx.context.session = { session, user };
+    }),
+});
+const remitMcpBridge = (identity, resource, oauthOptions, signInEnabled) => ({
+    id: "remit-mcp",
+    endpoints: {
+        ...("signIn" in identity.browser
+            ? { remitMcpSignIn: signInEndpoint(identity.browser.signIn, identity) }
+            : {}),
+        remitMcpVerifyAccessToken: createAuthEndpoint("/mcp/verify-access-token", {
+            method: "POST",
+            body: z.object({ token: z.string() }),
+            metadata: { SERVER_ONLY: true },
+        }, async (ctx) => {
+            if (!signInEnabled) {
+                throw new APIError("UNAUTHORIZED", { error: "invalid_token" });
+            }
+            const payload = await getOAuthProviderApi(ctx, oauthOptions).requireActiveAccessToken(ctx.body.token);
+            const clientId = payload.azp ?? payload.client_id;
+            if (typeof payload.sub !== "string" || typeof clientId !== "string") {
+                throw new APIError("UNAUTHORIZED", { error: "invalid_token" });
+            }
+            const consent = await ctx.context.adapter.findOne({
+                model: "oauthConsent",
+                where: grantOf(payload.sub, clientId),
+            });
+            if (!consent) {
+                throw new APIError("UNAUTHORIZED", {
+                    error: "invalid_token",
+                    error_description: "The user disconnected this client",
+                });
+            }
+            if (await identity.isDisabled(payload.sub)) {
+                throw new APIError("UNAUTHORIZED", {
+                    error: "invalid_token",
+                    error_description: "The account is disabled",
+                });
+            }
+            return ctx.json(payload);
+        }),
+        remitMcpConnectedApps: createAuthEndpoint(CONNECTED_APPS_API_PATH, { method: "GET", use: [sessionMiddleware] }, async (ctx) => {
+            const consents = await ctx.context.adapter.findMany({
+                model: "oauthConsent",
+                where: [{ field: "userId", value: ctx.context.session.user.id }],
+            });
+            const apps = new Map();
+            for (const consent of consents) {
+                const known = apps.get(consent.clientId);
+                if (known) {
+                    known.scopes = [...new Set([...known.scopes, ...consent.scopes])];
+                    continue;
+                }
+                const client = await ctx.context.adapter.findOne({
+                    model: "oauthClient",
+                    where: [{ field: "clientId", value: consent.clientId }],
+                });
+                apps.set(consent.clientId, {
+                    clientId: consent.clientId,
+                    clientName: client?.name ?? consent.clientId,
+                    scopes: consent.scopes,
+                    connectedAt: consent.createdAt,
+                });
+            }
+            return ctx.json({ apps: [...apps.values()] });
+        }),
+        remitMcpRevokeClient: createAuthEndpoint(REVOKE_CLIENT_API_PATH, {
+            method: "POST",
+            use: [sessionMiddleware],
+            body: z.object({ client_id: z.string().min(1) }),
+        }, async (ctx) => {
+            const grant = grantOf(ctx.context.session.user.id, ctx.body.client_id);
+            const revoked = new Date();
+            await ctx.context.adapter.deleteMany({
+                model: "oauthConsent",
+                where: grant,
+            });
+            await ctx.context.adapter.updateMany({
+                model: "oauthRefreshToken",
+                where: grant,
+                update: { revoked },
+            });
+            await ctx.context.adapter.updateMany({
+                model: "oauthAccessToken",
+                where: grant,
+                update: { revoked },
+            });
+            return ctx.json({ revoked: true });
+        }),
+    },
+    hooks: {
+        before: [
+            ...("subjectOf" in identity.browser
+                ? [subjectSession(identity.browser.subjectOf, identity)]
+                : []),
+            {
+                matcher: (ctx) => ctx.path === "/oauth2/authorize",
+                handler: createAuthMiddleware(async (ctx) => {
+                    const query = withOfflineAccess(ctx.query ?? {});
+                    return {
+                        context: {
+                            query: hasResource(query) ? query : { ...query, resource },
+                        },
+                    };
+                }),
+            },
+            {
+                matcher: (ctx) => ctx.path === DEVICE_APPROVE_PATH,
+                handler: createAuthMiddleware(async (ctx) => {
+                    const session = await getSessionFromCtx(ctx);
+                    const userCode = userCodeOf(ctx.body);
+                    if (!session || !userCode)
+                        return;
+                    const deviceCode = await deviceCodeOf(ctx, userCode);
+                    if (!deviceCode?.oauthClientId)
+                        return;
+                    const client = await ctx.context.adapter.findOne({
+                        model: "oauthClient",
+                        where: [{ field: "clientId", value: deviceCode.oauthClientId }],
+                    });
+                    if (client?.userId && client.userId !== session.user.id) {
+                        throw new APIError("FORBIDDEN", {
+                            error: "access_denied",
+                            error_description: "This device belongs to another account",
+                        });
+                    }
+                    await ctx.context.adapter.update({
+                        model: "oauthClient",
+                        where: [{ field: "clientId", value: deviceCode.oauthClientId }],
+                        update: { userId: session.user.id },
+                    });
+                }),
+            },
+            {
+                matcher: (ctx) => ctx.path === "/oauth2/token" && !hasResource(ctx.body),
+                handler: createAuthMiddleware(async (ctx) => ({
+                    context: { body: { ...ctx.body, resource } },
+                })),
+            },
+            {
+                matcher: (ctx) => ctx.path === DEVICE_CODE_PATH && !hasResource(ctx.body),
+                handler: createAuthMiddleware(async (ctx) => ({
+                    context: { body: { ...ctx.body, resource } },
+                })),
+            },
+            {
+                matcher: (ctx) => ctx.path === "/oauth2/register",
+                handler: createAuthMiddleware(async (ctx) => {
+                    const uris = redirectUrisOf(ctx.body);
+                    const refused = uris.find((uri) => typeof uri !== "string" || !isAllowedRedirectUri(uri));
+                    const missing = uris.length === 0 && !isDeviceOnlyClient(ctx.body);
+                    if (missing || refused !== undefined) {
+                        throw new APIError("BAD_REQUEST", {
+                            error: "invalid_redirect_uri",
+                            error_description: `redirect_uris must be ${ALLOWED_REDIRECT_URIS.join(" or ")}, or a loopback address`,
+                        });
+                    }
+                }),
+            },
+        ],
+        after: [
+            {
+                matcher: (ctx) => ctx.path === DEVICE_APPROVE_PATH,
+                handler: createAuthMiddleware(async (ctx) => {
+                    if (isAPIError(ctx.context.returned))
+                        return;
+                    const session = await getSessionFromCtx(ctx);
+                    const userCode = userCodeOf(ctx.body);
+                    if (!session || !userCode)
+                        return;
+                    const deviceCode = await deviceCodeOf(ctx, userCode);
+                    if (!deviceCode?.oauthClientId)
+                        return;
+                    const grant = grantOf(session.user.id, deviceCode.oauthClientId);
+                    const existing = await ctx.context.adapter.findOne({
+                        model: "oauthConsent",
+                        where: grant,
+                    });
+                    if (existing)
+                        return;
+                    const now = new Date();
+                    await ctx.context.adapter.create({
+                        model: "oauthConsent",
+                        data: {
+                            clientId: deviceCode.oauthClientId,
+                            userId: session.user.id,
+                            scopes: (deviceCode.scope ?? "")
+                                .split(" ")
+                                .filter((scope) => scope.length > 0),
+                            resources: deviceCode.resources ?? [resource],
+                            createdAt: now,
+                            updatedAt: now,
+                        },
+                    });
+                }),
+            },
+        ],
+    },
+});
+/**
+ * The kill switch on the connector's own better-auth instance: with
+ * `SIGN_IN_ENABLED` off every path but the JWKS and the server metadata is
+ * refused, so no one signs in, consents or exchanges a token.
+ */
+const signInGate = (signInEnabled) => createAuthMiddleware(async (ctx) => {
+    if (signInEnabled || isAlwaysServed(ctx.path))
+        return;
+    throw new APIError("FORBIDDEN", { ...SIGN_IN_DISABLED });
+});
+export const buildMcpAuthOptions = (config, database, identity) => {
+    const oauthOptions = buildOAuthOptions(config.origin);
+    return {
+        secret: config.secret,
+        baseURL: config.origin,
+        basePath: AUTH_BASE_PATH,
+        trustedOrigins: [config.origin],
+        database,
+        disabledPaths: ["/token"],
+        hooks: { before: signInGate(config.signInEnabled) },
+        advanced: {
+            cookiePrefix: "remit-mcp",
+            ipAddress: { ipAddressHeaders: [CLIENT_IP_HEADER] },
+        },
+        rateLimit: {
+            enabled: true,
+            customRules: { [SIGN_IN_PATH]: { window: 60, max: 5 } },
+        },
+        user: { modelName: "auth_user" },
+        account: { modelName: "auth_account" },
+        session: { modelName: "mcp_session", storeSessionInDatabase: true },
+        verification: { modelName: "mcp_verification" },
+        plugins: [
+            jwt({
+                schema: { jwks: { modelName: "mcp_jwks" } },
+                disableSettingJwtHeader: true,
+                jwt: { issuer: config.origin, audience: mcpResource(config.origin) },
+            }),
+            oauthProvider(oauthOptions),
+            oauthDeviceAuthorization({
+                schema: { deviceCode: { modelName: "mcp_device_code" } },
+                verificationUri: `${config.origin}${DEVICE_PATH}`,
+            }),
+            remitMcpBridge(identity, mcpResource(config.origin), oauthOptions, config.signInEnabled),
+        ],
+    };
+};
+const createBetterAuth = (config, database, identity) => betterAuth(buildMcpAuthOptions(config, database, identity));
+export const createMcpAuth = (config, database, identity) => {
+    const auth = createBetterAuth(config, database, identity);
+    return { auth, routes: createMcpAuthRoutes(auth, identity) };
+};
+const DEVICE_AUTH_PATHS = new Set([
+    DEVICE_CODE_PATH,
+    DEVICE_PATH,
+    DEVICE_APPROVE_PATH,
+    DEVICE_DENY_PATH,
+]);
+const jsonHeaders = (headers) => {
+    const json = new Headers(headers);
+    json.set("accept", "application/json");
+    json.set("content-type", "application/json");
+    return json;
+};
+const postToRouter = (auth, headers, path, body) => auth.handler(new Request(`${auth.options.baseURL}${AUTH_BASE_PATH}${path}`, {
+    method: "POST",
+    headers: jsonHeaders(headers),
+    body: JSON.stringify(body),
+}));
+const refusedWith = (error) => {
+    if (isAPIError(error))
+        return undefined;
+    throw error;
+};
+const refusalResponse = (error) => {
+    if (!isAPIError(error))
+        throw error;
+    return Response.json(error.body ?? {}, { status: error.statusCode });
+};
+const isServedAuthPath = (path) => path.startsWith(OAUTH2_PATH_PREFIX) ||
+    DEVICE_AUTH_PATHS.has(path) ||
+    path === SIGN_IN_PATH ||
+    path === CONNECTED_APPS_API_PATH ||
+    path === REVOKE_CLIENT_API_PATH ||
+    path === JWKS_PATH;
+const SUBJECT_SERVED_PATHS = new Set([
+    ...BROWSER_PATHS,
+    ...DEVICE_AUTH_PATHS,
+    "/oauth2/register",
+    "/oauth2/token",
+    "/oauth2/revoke",
+    JWKS_PATH,
+]);
+const browserRoutesOf = (auth, browser) => "signIn" in browser
+    ? {
+        kind: "signIn",
+        // Through the router rather than auth.api: only the router applies
+        // the sign-in rate limit.
+        signIn: (headers, body) => postToRouter(auth, headers, SIGN_IN_PATH, body),
+    }
+    : { kind: "host" };
+const subjectIdOf = async (auth, browser, headers) => {
+    if ("subjectOf" in browser)
+        return (await browser.subjectOf(headers))?.id;
+    return (await auth.api.getSession({ headers }))?.user.id;
+};
+const createMcpAuthRoutes = (auth, identity) => ({
+    browser: browserRoutesOf(auth, identity.browser),
+    handle: async (request) => {
+        const { pathname } = new URL(request.url);
+        if (!pathname.startsWith(AUTH_BASE_PATH)) {
+            return new Response("Not found", { status: 404 });
+        }
+        const path = pathname.slice(AUTH_BASE_PATH.length);
+        const served = "subjectOf" in identity.browser
+            ? SUBJECT_SERVED_PATHS.has(path)
+            : isServedAuthPath(path);
+        if (!served)
+            return new Response("Not found", { status: 404 });
+        return auth.handler(request);
+    },
+    serverMetadata: oauthProviderAuthServerMetadata(auth),
+    sessionOf: async (headers) => {
+        const userId = await subjectIdOf(auth, identity.browser, headers);
+        if (userId === undefined)
+            return "absent";
+        return (await identity.isDisabled(userId)) ? "disabled" : "active";
+    },
+    // Through the router rather than auth.api: the authorization it resumes
+    // needs a request.
+    consent: (headers, body) => postToRouter(auth, headers, "/oauth2/consent", body),
+    clientName: async (headers, clientId) => {
+        const client = await auth.api
+            .getOAuthClientPublic({ query: { client_id: clientId }, headers })
+            .catch(refusedWith);
+        if (!client)
+            return undefined;
+        return client.client_name ?? clientId;
+    },
+    claimDeviceCode: async (headers, userCode) => {
+        const response = await auth.api.deviceVerify({
+            query: { user_code: userCode },
+            headers,
+            asResponse: true,
+        });
+        await response.body?.cancel();
+        return response.ok;
+    },
+    decideDeviceCode: (headers, userCode, approve) => (approve
+        ? auth.api.deviceApprove({
+            body: { userCode },
+            headers: jsonHeaders(headers),
+            asResponse: true,
+        })
+        : auth.api.deviceDeny({
+            body: { userCode },
+            headers: jsonHeaders(headers),
+            asResponse: true,
+        })).catch(refusalResponse),
+    connectedApps: (headers) => auth.api
+        .remitMcpConnectedApps({ headers, asResponse: true })
+        .catch(refusalResponse),
+    revokeClient: (headers, clientId) => auth.api
+        .remitMcpRevokeClient({
+        body: { client_id: clientId },
+        headers: jsonHeaders(headers),
+        asResponse: true,
+    })
+        .catch(refusalResponse),
+});
+const audienceOf = (aud) => {
+    if (typeof aud === "string")
+        return [aud];
+    if (Array.isArray(aud)) {
+        return aud.filter((value) => typeof value === "string");
+    }
+    return [];
+};
+export const createBetterAuthTokenVerifier = (auth, origin) => ({
+    async verify(bearer) {
+        const payload = await auth.api
+            .remitMcpVerifyAccessToken({ body: { token: bearer } })
+            .catch((error) => {
+            if (isAPIError(error))
+                return undefined;
+            throw error;
+        });
+        if (!payload)
+            return { ok: false, reason: "invalid_token" };
+        if (!audienceOf(payload.aud).includes(mcpResource(origin))) {
+            return { ok: false, reason: "wrong_audience" };
+        }
+        if (typeof payload.sub !== "string" || payload.sub.length === 0) {
+            return { ok: false, reason: "no_subject" };
+        }
+        const scopes = typeof payload.scope === "string"
+            ? payload.scope.split(" ").filter((scope) => scope.length > 0)
+            : [];
+        return { ok: true, principal: { userId: payload.sub, scopes } };
+    },
+});

package/dist/auth/database.d.ts

@@ -0,0 +1,7 @@
+import { type BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
+export interface McpAuthDatabase {
+    db: BetterSQLite3Database;
+    close: () => void;
+}
+export declare const refuseSharedTableWrites: (db: BetterSQLite3Database) => BetterSQLite3Database;
+export declare const openMcpAuthDatabase: (filename: string) => McpAuthDatabase;

package/dist/auth/database.js

@@ -0,0 +1,33 @@
+import { auth_account, auth_user } from "@remit/auth-service/schema";
+import Database from "better-sqlite3";
+import { drizzle, } from "drizzle-orm/better-sqlite3";
+const SHARED_TABLES = new Set([auth_user, auth_account]);
+const WRITES = new Set([
+    "insert",
+    "update",
+    "delete",
+]);
+export const refuseSharedTableWrites = (db) => new Proxy(db, {
+    get(target, property, receiver) {
+        const value = Reflect.get(target, property, receiver);
+        if (!WRITES.has(property) || typeof value !== "function")
+            return value;
+        return (table) => {
+            if (SHARED_TABLES.has(table)) {
+                throw new Error("The MCP server never writes the shared auth_user or auth_account tables");
+            }
+            return value.call(target, table);
+        };
+    },
+});
+export const openMcpAuthDatabase = (filename) => {
+    const sqlite = new Database(filename);
+    sqlite.pragma("journal_mode = WAL");
+    sqlite.pragma("busy_timeout = 5000");
+    sqlite.pragma("synchronous = NORMAL");
+    sqlite.pragma("foreign_keys = ON");
+    return {
+        db: drizzle(sqlite),
+        close: () => sqlite.close(),
+    };
+};

package/dist/auth/node-auth.d.ts

@@ -0,0 +1,3 @@
+import type { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
+import { type McpAuthConfig, type McpAuthServer } from "./authorization-server.js";
+export declare const createSqliteMcpAuth: (config: McpAuthConfig, db: BetterSQLite3Database) => McpAuthServer;

package/dist/auth/node-auth.js

@@ -0,0 +1,17 @@
+import { isUserDisabled, writeAudit } from "@remit/auth-service";
+import { auth_account, auth_user } from "@remit/auth-service/schema";
+import * as mcpTables from "@remit/drizzle-service/schema-sets/mcp";
+import { drizzleAdapter } from "better-auth/adapters/drizzle";
+import { createMcpAuth, } from "./authorization-server.js";
+import { refuseSharedTableWrites } from "./database.js";
+import { checkRemitPassword } from "./remit-password.js";
+export const createSqliteMcpAuth = (config, db) => createMcpAuth(config, drizzleAdapter(refuseSharedTableWrites(db), {
+    provider: "sqlite",
+    schema: { ...mcpTables, auth_user, auth_account },
+}), {
+    isDisabled: async (userId) => isUserDisabled(db, userId),
+    audit: async (record) => writeAudit(db, record),
+    browser: {
+        signIn: (email, password) => checkRemitPassword(db, email, password),
+    },
+});

package/dist/auth/remit-password.d.ts

@@ -0,0 +1,8 @@
+import type { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
+export type PasswordCheck = {
+    ok: true;
+    userId: string;
+} | {
+    ok: false;
+};
+export declare const checkRemitPassword: (db: BetterSQLite3Database, email: string, password: string) => Promise<PasswordCheck>;

package/dist/auth/remit-password.js

@@ -0,0 +1,18 @@
+import { auth_account, auth_user } from "@remit/auth-service/schema";
+import { verifyPassword } from "better-auth/crypto";
+import { and, eq } from "drizzle-orm";
+const CREDENTIAL_PROVIDER = "credential";
+export const checkRemitPassword = async (db, email, password) => {
+    const [row] = await db
+        .select({ id: auth_user.id, hash: auth_account.password })
+        .from(auth_user)
+        .innerJoin(auth_account, and(eq(auth_account.userId, auth_user.id), eq(auth_account.providerId, CREDENTIAL_PROVIDER)))
+        .where(eq(auth_user.email, email.trim().toLowerCase()))
+        .limit(1);
+    if (!row?.hash)
+        return { ok: false };
+    if (!(await verifyPassword({ hash: row.hash, password }))) {
+        return { ok: false };
+    }
+    return { ok: true, userId: row.id };
+};