@sigma-auth/better-auth-plugin 0.0.1

package/dist/provider/index.js

@@ -0,0 +1,717 @@
+import { PublicKey } from "@bsv/sdk";
+import { APIError, createAuthEndpoint, sessionMiddleware, } from "better-auth/api";
+import { setSessionCookie } from "better-auth/cookies";
+import { createAuthMiddleware } from "better-auth/plugins";
+import { parseAuthToken, verifyAuthToken } from "bitcoin-auth";
+import { z } from "zod";
+/**
+ * Sigma Auth provider plugin for Better Auth
+ * This is the OAuth provider that runs on auth.sigmaidentity.com
+ *
+ * @example
+ * ```typescript
+ * import { betterAuth } from "better-auth";
+ * import { sigmaProvider } from "@sigma-auth/better-auth-plugin/provider";
+ *
+ * export const auth = betterAuth({
+ *   plugins: [
+ *     sigmaProvider({
+ *       getPool: () => dbPool,
+ *       cache: redisCache,
+ *       resolveBAPId: async (pool, userId, pubkey, register) => {
+ *         // Custom BAP ID resolution logic
+ *       },
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export const sigmaProvider = (options) => ({
+    id: "sigma",
+    schema: {
+        user: {
+            fields: {
+                pubkey: {
+                    type: "string",
+                    required: true,
+                    unique: true,
+                },
+                ...(options?.enableSubscription
+                    ? {
+                        subscriptionTier: {
+                            type: "string",
+                            required: false,
+                            defaultValue: "free",
+                        },
+                    }
+                    : {}),
+            },
+        },
+        session: {
+            fields: {
+                ...(options?.enableSubscription
+                    ? {
+                        subscriptionTier: {
+                            type: "string",
+                            required: false,
+                        },
+                    }
+                    : {}),
+            },
+        },
+        oauthAccessToken: {
+            fields: {
+                selectedBapId: {
+                    type: "string",
+                    required: false,
+                },
+            },
+        },
+        oauthApplication: {
+            fields: {
+                owner_bap_id: {
+                    type: "string",
+                    required: true,
+                },
+            },
+        },
+        oauthConsent: {
+            fields: {
+                selectedBapId: {
+                    type: "string",
+                    required: false,
+                },
+            },
+        },
+    },
+    hooks: {
+        after: [
+            {
+                matcher: (ctx) => ctx.path === "/oauth2/token",
+                handler: createAuthMiddleware(async (ctx) => {
+                    console.log("🔵 [Sigma Plugin] AFTER hook triggered for /oauth2/token");
+                    const body = ctx.body;
+                    const grantType = body.grant_type;
+                    // Only handle authorization_code grant (not refresh_token)
+                    if (grantType !== "authorization_code") {
+                        return;
+                    }
+                    // Check if token exchange was successful
+                    const responseBody = ctx.context.returned;
+                    if (!responseBody ||
+                        typeof responseBody !== "object" ||
+                        !("access_token" in responseBody)) {
+                        return; // Token exchange failed, skip BAP ID storage
+                    }
+                    // Only proceed if we have cache option
+                    if (!options?.cache) {
+                        return;
+                    }
+                    try {
+                        // Get the access token from response to find the related consent
+                        const accessToken = responseBody
+                            .access_token;
+                        // Query the access token record to get userId and clientId using adapter
+                        const tokenRecords = await ctx.context.adapter.findMany({
+                            model: "oauthAccessToken",
+                            where: [{ field: "accessToken", value: accessToken }],
+                            limit: 1,
+                        });
+                        if (tokenRecords.length === 0 || !tokenRecords[0]) {
+                            console.warn("⚠️ [OAuth Token Hook] No access token found in database");
+                            return;
+                        }
+                        const { userId, clientId } = tokenRecords[0];
+                        // Query the most recent consent record for this user/client to get selectedBapId
+                        const consentRecords = await ctx.context.adapter.findMany({
+                            model: "oauthConsent",
+                            where: [
+                                { field: "userId", value: userId },
+                                { field: "clientId", value: clientId },
+                            ],
+                            limit: 1,
+                            sortBy: { field: "createdAt", direction: "desc" },
+                        });
+                        const consentRecord = consentRecords[0];
+                        if (!consentRecord || !consentRecord.selectedBapId) {
+                            return;
+                        }
+                        const selectedBapId = consentRecord.selectedBapId;
+                        // Update the oauthAccessToken record with the selected BAP ID
+                        await ctx.context.adapter.update({
+                            model: "oauthAccessToken",
+                            where: [{ field: "accessToken", value: accessToken }],
+                            update: {
+                                selectedBapId,
+                            },
+                        });
+                        console.log(`✅ [OAuth Token Hook] Stored BAP ID in access token: user=${userId.substring(0, 15)}... bap=${selectedBapId.substring(0, 15)}...`);
+                        // Update user record with selected identity's profile data
+                        if (options?.getPool) {
+                            const pool = options.getPool();
+                            const client = await pool.connect();
+                            try {
+                                // Query profile table for selected identity
+                                const profileResult = await client.query("SELECT bap_id, name, image, member_pubkey FROM profile WHERE bap_id = $1 AND user_id = $2 LIMIT 1", [selectedBapId, userId]);
+                                const profile = profileResult.rows[0];
+                                if (profile) {
+                                    // Update user record with profile data
+                                    await ctx.context.adapter.update({
+                                        model: "user",
+                                        where: [{ field: "id", value: userId }],
+                                        update: {
+                                            name: profile.name,
+                                            image: profile.image,
+                                            ...(profile.member_pubkey && {
+                                                pubkey: profile.member_pubkey,
+                                            }),
+                                            updatedAt: new Date(),
+                                        },
+                                    });
+                                }
+                            }
+                            finally {
+                                client.release();
+                            }
+                        }
+                    }
+                    catch (error) {
+                        console.error("❌ [OAuth Token] Error storing identity selection:", error);
+                    }
+                }),
+            },
+            {
+                matcher: (ctx) => ctx.path === "/oauth2/userinfo",
+                handler: createAuthMiddleware(async (ctx) => {
+                    // Get the access token from Authorization header
+                    const authHeader = ctx.headers?.get?.("authorization");
+                    if (!authHeader || !authHeader.startsWith("Bearer ")) {
+                        return;
+                    }
+                    const accessToken = authHeader.substring(7);
+                    try {
+                        // Look up the access token record to get selectedBapId using adapter
+                        const tokenRecords = await ctx.context.adapter.findMany({
+                            model: "oauthAccessToken",
+                            where: [{ field: "accessToken", value: accessToken }],
+                            limit: 1,
+                        });
+                        const tokenRecord = tokenRecords[0];
+                        if (!tokenRecord || !tokenRecord.selectedBapId) {
+                            return; // No selected BAP ID, use primary (default behavior)
+                        }
+                        const selectedBapId = tokenRecord.selectedBapId;
+                        // Get BAP ID details from profile table using getPool if available
+                        if (!options?.getPool) {
+                            return;
+                        }
+                        const pool = options.getPool();
+                        const client = await pool.connect();
+                        try {
+                            const bapResult = await client.query("SELECT bap_id, name, image, profile FROM profile WHERE bap_id = $1 LIMIT 1", [selectedBapId]);
+                            if (bapResult.rows.length === 0) {
+                                throw new Error(`Selected identity not found: ${selectedBapId}`);
+                            }
+                            const selectedName = bapResult.rows[0].name;
+                            let selectedImage = bapResult.rows[0].image;
+                            let profileData = bapResult.rows[0].profile;
+                            // If profile JSONB is NULL, fetch from blockchain and populate it
+                            if (!profileData) {
+                                try {
+                                    const profileResponse = await fetch("https://api.sigmaidentity.com/api/v1/identity/get", {
+                                        method: "POST",
+                                        headers: { "Content-Type": "application/json" },
+                                        body: JSON.stringify({ idKey: selectedBapId }),
+                                    });
+                                    if (profileResponse.ok) {
+                                        const apiData = (await profileResponse.json());
+                                        if (apiData.result) {
+                                            profileData = apiData.result;
+                                            // Update database with complete profile JSONB
+                                            await client.query(`UPDATE profile SET
+													profile = $1,
+													image = COALESCE($2, image),
+													updated_at = NOW()
+												WHERE bap_id = $3`, [
+                                                JSON.stringify(profileData),
+                                                profileData.identity?.image || null,
+                                                selectedBapId,
+                                            ]);
+                                            if (profileData.identity?.image) {
+                                                selectedImage = profileData.identity.image;
+                                            }
+                                        }
+                                    }
+                                }
+                                catch (fetchError) {
+                                    console.error(`❌ [OAuth Userinfo] Failed to fetch profile:`, fetchError);
+                                }
+                            }
+                            // Modify the response to use selected BAP ID instead of primary
+                            const responseBody = ctx.context.returned;
+                            if (responseBody && typeof responseBody === "object") {
+                                // Fetch the member pubkey for this BAP ID from KV reverse index
+                                let memberPubkey = null;
+                                if (options.cache) {
+                                    try {
+                                        const reverseKey = `bap:member_pubkey:${selectedBapId}`;
+                                        memberPubkey = await options.cache.get(reverseKey);
+                                    }
+                                    catch (error) {
+                                        console.error(`❌ [OAuth Userinfo] Error fetching member pubkey:`, error);
+                                    }
+                                }
+                                // Return the modified userinfo response
+                                return {
+                                    ...responseBody,
+                                    // Standard OIDC claims
+                                    name: selectedName,
+                                    given_name: profileData?.identity?.givenName || selectedName,
+                                    family_name: profileData?.identity?.familyName || null,
+                                    picture: selectedImage || responseBody.picture || null,
+                                    // Custom claims
+                                    pubkey: memberPubkey || responseBody.pubkey,
+                                    bap: profileData || null,
+                                };
+                            }
+                        }
+                        finally {
+                            client.release();
+                        }
+                    }
+                    catch (error) {
+                        console.error("❌ [OAuth Userinfo] Error retrieving selected BAP ID:", error);
+                    }
+                }),
+            },
+            {
+                matcher: (ctx) => ctx.path === "/oauth2/consent",
+                handler: createAuthMiddleware(async (ctx) => {
+                    // Only proceed if we have cache option
+                    if (!options?.cache) {
+                        return;
+                    }
+                    const body = ctx.body;
+                    const consentCode = body.consent_code;
+                    const accept = body.accept;
+                    // Only store selectedBapId if consent was accepted
+                    if (!accept || !consentCode) {
+                        return;
+                    }
+                    try {
+                        // Get session for userId
+                        const session = ctx.context.session;
+                        if (!session?.user?.id) {
+                            return;
+                        }
+                        // Wait a bit for Better Auth to create the consent record
+                        await new Promise((resolve) => setTimeout(resolve, 100));
+                        // Query the database to get the clientId from the consent record
+                        const consentRecords = await ctx.context.adapter.findMany({
+                            model: "oauthConsent",
+                            where: [{ field: "userId", value: session.user.id }],
+                            limit: 1,
+                            sortBy: { field: "createdAt", direction: "desc" },
+                        });
+                        const consentRecord = consentRecords[0];
+                        if (!consentRecord) {
+                            return;
+                        }
+                        const { id: consentId } = consentRecord;
+                        // Retrieve selected BAP ID from cache/KV
+                        const selectedBapId = await options.cache.get(`consent:${consentCode}:bap_id`);
+                        if (!selectedBapId) {
+                            return;
+                        }
+                        // Update the consent record with selectedBapId using adapter
+                        await ctx.context.adapter.update({
+                            model: "oauthConsent",
+                            where: [{ field: "id", value: consentId }],
+                            update: {
+                                selectedBapId,
+                            },
+                        });
+                        console.log(`✅ [OAuth Consent Hook] Stored BAP ID in consent: user=${session.user.id.substring(0, 15)}... bap=${selectedBapId.substring(0, 15)}...`);
+                    }
+                    catch (error) {
+                        console.error("❌ [OAuth Consent Hook] Error storing identity selection:", error);
+                    }
+                }),
+            },
+        ],
+        before: [
+            {
+                matcher: (ctx) => ctx.path === "/oauth2/token",
+                handler: createAuthMiddleware(async (ctx) => {
+                    const body = ctx.body;
+                    const grantType = body.grant_type;
+                    // Handle authorization_code grant type (exchange code for token)
+                    if (grantType === "authorization_code") {
+                        // Get client_id from request body
+                        const clientId = body.client_id;
+                        if (!clientId) {
+                            throw new APIError("BAD_REQUEST", {
+                                message: "Missing client_id in request body",
+                            });
+                        }
+                        // Lookup OAuth client by client_id
+                        const clients = await ctx.context.adapter.findMany({
+                            model: "oauthApplication",
+                            where: [{ field: "clientId", value: clientId }],
+                        });
+                        if (clients.length === 0) {
+                            throw new APIError("UNAUTHORIZED", {
+                                message: `OAuth client not registered: ${clientId}`,
+                            });
+                        }
+                        const client = clients[0];
+                        // Validate client authentication via Bitcoin signature
+                        const headers = new Headers(ctx.headers || {});
+                        const authToken = headers.get("x-auth-token");
+                        if (!authToken) {
+                            throw new APIError("UNAUTHORIZED", {
+                                message: "Missing X-Auth-Token header for client authentication",
+                            });
+                        }
+                        // Parse the auth token to extract pubkey
+                        const parsed = parseAuthToken(authToken);
+                        if (!parsed?.pubkey) {
+                            throw new APIError("UNAUTHORIZED", {
+                                message: "Invalid Bitcoin auth token format",
+                            });
+                        }
+                        // Verify the pubkey from signature matches the client's memberPubkey
+                        if (!client.metadata) {
+                            throw new APIError("UNAUTHORIZED", {
+                                message: `Client ${clientId} has no metadata`,
+                            });
+                        }
+                        const metadata = JSON.parse(client.metadata);
+                        const expectedPubkey = metadata.memberPubkey;
+                        if (!expectedPubkey) {
+                            throw new APIError("UNAUTHORIZED", {
+                                message: `Client ${clientId} has no memberPubkey in metadata`,
+                            });
+                        }
+                        if (parsed.pubkey !== expectedPubkey) {
+                            throw new APIError("UNAUTHORIZED", {
+                                message: "Bitcoin signature pubkey does not match client",
+                            });
+                        }
+                        // Get request body for signature verification
+                        const bodyString = new URLSearchParams(Object.entries(body).map(([k, v]) => [k, String(v)])).toString();
+                        // Verify Bitcoin signature with body
+                        const verifyData = {
+                            requestPath: "/oauth2/token",
+                            timestamp: parsed.timestamp,
+                            body: bodyString,
+                        };
+                        const isValid = verifyAuthToken(authToken, verifyData, 5);
+                        if (!isValid) {
+                            throw new APIError("UNAUTHORIZED", {
+                                message: "Invalid Bitcoin signature",
+                            });
+                        }
+                        console.log(`✅ [OAuth Token] Client authenticated via Bitcoin signature (clientId: ${clientId})`);
+                        // Inject client_id into request body for Better Auth to process
+                        const modifiedBody = {
+                            ...ctx.body,
+                            client_id: clientId,
+                        };
+                        return {
+                            context: {
+                                ...ctx,
+                                body: modifiedBody,
+                            },
+                        };
+                    }
+                    // Handle refresh_token grant type
+                    if (grantType === "refresh_token") {
+                        const refreshToken = body.refresh_token;
+                        if (!refreshToken) {
+                            throw new APIError("BAD_REQUEST", {
+                                message: "Missing refresh_token",
+                            });
+                        }
+                        // Get client_id from request body
+                        const clientId = body.client_id;
+                        if (!clientId) {
+                            throw new APIError("BAD_REQUEST", {
+                                message: "Missing client_id in request body",
+                            });
+                        }
+                        // Lookup OAuth client by client_id
+                        const clients = await ctx.context.adapter.findMany({
+                            model: "oauthApplication",
+                            where: [{ field: "clientId", value: clientId }],
+                        });
+                        if (clients.length === 0) {
+                            throw new APIError("UNAUTHORIZED", {
+                                message: `OAuth client not registered: ${clientId}`,
+                            });
+                        }
+                        const client = clients[0];
+                        // Validate client signature first
+                        const headers = new Headers(ctx.headers || {});
+                        const authToken = headers.get("x-auth-token");
+                        if (!authToken) {
+                            throw new APIError("UNAUTHORIZED", {
+                                message: "Missing X-Auth-Token header for client authentication",
+                            });
+                        }
+                        const parsed = parseAuthToken(authToken);
+                        if (!parsed?.pubkey) {
+                            throw new APIError("UNAUTHORIZED", {
+                                message: "Invalid Bitcoin auth token format",
+                            });
+                        }
+                        if (!client.metadata) {
+                            throw new APIError("UNAUTHORIZED", {
+                                message: `Client ${clientId} has no metadata`,
+                            });
+                        }
+                        const metadata = JSON.parse(client.metadata);
+                        const expectedPubkey = metadata.memberPubkey;
+                        if (!expectedPubkey) {
+                            throw new APIError("UNAUTHORIZED", {
+                                message: `Client ${clientId} has no memberPubkey in metadata`,
+                            });
+                        }
+                        if (parsed.pubkey !== expectedPubkey) {
+                            throw new APIError("UNAUTHORIZED", {
+                                message: "Bitcoin signature pubkey does not match client",
+                            });
+                        }
+                        const bodyString = new URLSearchParams(Object.entries(body).map(([k, v]) => [k, String(v)])).toString();
+                        const verifyData = {
+                            requestPath: "/oauth2/token",
+                            timestamp: parsed.timestamp,
+                            body: bodyString,
+                        };
+                        const isValid = verifyAuthToken(authToken, verifyData, 5);
+                        if (!isValid) {
+                            throw new APIError("UNAUTHORIZED", {
+                                message: "Invalid Bitcoin signature",
+                            });
+                        }
+                        console.log(`✅ [OAuth Token Refresh] Client authenticated via Bitcoin signature (clientId: ${clientId})`);
+                        // Inject client_id into request body for Better Auth to process
+                        const modifiedBody = {
+                            ...ctx.body,
+                            client_id: clientId,
+                        };
+                        return {
+                            context: {
+                                ...ctx,
+                                body: modifiedBody,
+                            },
+                        };
+                    }
+                    // Unknown grant type
+                    throw new APIError("BAD_REQUEST", {
+                        message: `Unsupported grant_type: ${grantType}`,
+                    });
+                }),
+            },
+        ],
+    },
+    endpoints: {
+        /**
+         * Store selected BAP ID for OAuth consent
+         */
+        storeConsentBapId: createAuthEndpoint("/sigma/store-consent-bap-id", {
+            method: "POST",
+            body: z.object({
+                consentCode: z.string(),
+                bapId: z.string(),
+            }),
+            use: [sessionMiddleware],
+        }, async (ctx) => {
+            // Session is guaranteed to exist due to sessionMiddleware
+            const _session = ctx.context.session;
+            // Validate options
+            if (!options?.cache) {
+                throw new APIError("INTERNAL_SERVER_ERROR", {
+                    message: "Plugin configuration error: cache not available",
+                });
+            }
+            const { consentCode, bapId } = ctx.body;
+            try {
+                // Store in KV with 5 minute TTL
+                const kvKey = `consent:${consentCode}:bap_id`;
+                await options.cache.set(kvKey, bapId, { ex: 300 });
+                return ctx.json({ success: true });
+            }
+            catch (error) {
+                console.error("❌ [Store Consent BAP ID] Error storing selection:", error);
+                throw new APIError("INTERNAL_SERVER_ERROR", {
+                    message: "Failed to store identity selection",
+                });
+            }
+        }),
+        signInSigma: createAuthEndpoint("/sign-in/sigma", {
+            method: "POST",
+            body: z.optional(z.object({
+                bapId: z.string().optional(),
+            })),
+        }, async (ctx) => {
+            // Get auth token from header
+            const authToken = ctx.headers?.get("x-auth-token");
+            if (!authToken) {
+                throw new APIError("UNAUTHORIZED", {
+                    message: "No auth token provided",
+                });
+            }
+            // Parse the auth token
+            const parsed = parseAuthToken(authToken);
+            if (!parsed?.pubkey) {
+                throw new APIError("BAD_REQUEST", {
+                    message: "Invalid auth token format",
+                });
+            }
+            // Verify the auth token
+            const verifyData = {
+                requestPath: "/api/auth/sign-in/sigma",
+                timestamp: parsed.timestamp,
+            };
+            const isValid = verifyAuthToken(authToken, verifyData, 5);
+            if (!isValid) {
+                throw new APIError("UNAUTHORIZED", {
+                    message: "Invalid auth token signature",
+                });
+            }
+            // Extract pubkey from the parsed token
+            const pubkey = parsed.pubkey;
+            // Try to find user by pubkey first
+            const users = await ctx.context.adapter.findMany({
+                model: "user",
+                where: [{ field: "pubkey", value: pubkey }],
+            });
+            let user = users[0];
+            // If not found by user.pubkey, check profile table for member_pubkey
+            if (!user && options?.getPool) {
+                const pool = options.getPool();
+                const client = await pool.connect();
+                try {
+                    const profileResult = await client.query("SELECT user_id FROM profile WHERE member_pubkey = $1 LIMIT 1", [pubkey]);
+                    const profileRow = profileResult.rows[0];
+                    if (profileRow) {
+                        const userId = profileRow.user_id;
+                        // Fetch the user record
+                        const foundUsers = await ctx.context.adapter.findMany({
+                            model: "user",
+                            where: [{ field: "id", value: userId }],
+                        });
+                        user = foundUsers[0];
+                    }
+                }
+                finally {
+                    client.release();
+                }
+            }
+            if (!user) {
+                // Create new user with pubkey (no email)
+                try {
+                    user = (await ctx.context.adapter.create({
+                        model: "user",
+                        data: {
+                            name: PublicKey.fromString(pubkey).toAddress(),
+                            pubkey,
+                            emailVerified: false,
+                            createdAt: new Date(),
+                            updatedAt: new Date(),
+                        },
+                    }));
+                }
+                catch (error) {
+                    // If duplicate key error, try to find the user again by pubkey
+                    if (error &&
+                        typeof error === "object" &&
+                        "code" in error &&
+                        error.code === "23505") {
+                        const existingUsers = await ctx.context.adapter.findMany({
+                            model: "user",
+                            where: [{ field: "pubkey", value: pubkey }],
+                        });
+                        user = existingUsers[0];
+                        if (!user) {
+                            throw new APIError("INTERNAL_SERVER_ERROR", {
+                                message: "User exists but cannot be found",
+                            });
+                        }
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+            // Resolve BAP ID if resolver is provided
+            if (options?.resolveBAPId && options?.getPool) {
+                const pool = options.getPool();
+                const bapId = await options.resolveBAPId(pool, user.id, pubkey, true);
+                if (bapId) {
+                    console.log(`✅ BAP ID resolved and registered: ${bapId.substring(0, 20)}...`);
+                    // Update user record with profile data from profile table
+                    const selectedBapId = ctx.body?.bapId;
+                    const client = await pool.connect();
+                    try {
+                        let profileResult;
+                        if (selectedBapId) {
+                            // Query profile for selected identity
+                            profileResult = await client.query("SELECT bap_id, name, image, member_pubkey FROM profile WHERE bap_id = $1 AND user_id = $2 LIMIT 1", [selectedBapId, user.id]);
+                        }
+                        else {
+                            // Query for primary profile
+                            profileResult = await client.query("SELECT bap_id, name, image, member_pubkey FROM profile WHERE user_id = $1 AND is_primary = true LIMIT 1", [user.id]);
+                        }
+                        const selectedProfile = profileResult.rows[0];
+                        if (selectedProfile) {
+                            // Update user record with profile data
+                            await ctx.context.adapter.update({
+                                model: "user",
+                                where: [{ field: "id", value: user.id }],
+                                update: {
+                                    name: selectedProfile.name,
+                                    image: selectedProfile.image,
+                                    ...(selectedProfile.member_pubkey && {
+                                        pubkey: selectedProfile.member_pubkey,
+                                    }),
+                                    updatedAt: new Date(),
+                                },
+                            });
+                        }
+                    }
+                    finally {
+                        client.release();
+                    }
+                    // Re-fetch user to get updated profile data
+                    const updatedUsers = await ctx.context.adapter.findMany({
+                        model: "user",
+                        where: [{ field: "id", value: user.id }],
+                    });
+                    if (updatedUsers[0]) {
+                        user = updatedUsers[0];
+                    }
+                }
+            }
+            // Create session
+            const session = await ctx.context.internalAdapter.createSession(user.id, ctx);
+            if (!session) {
+                throw new APIError("INTERNAL_SERVER_ERROR", {
+                    message: "Internal Server Error",
+                    status: 500,
+                });
+            }
+            await setSessionCookie(ctx, { session, user });
+            return ctx.json({
+                token: session.token,
+                user: {
+                    id: user.id,
+                    pubkey: user.pubkey,
+                    name: user.name,
+                },
+            });
+        }),
+    },
+});
+//# sourceMappingURL=index.js.map