@lastbrain/module-auth 2.0.19 → 2.0.31

package/dist/api/auth/account/reset-password.js

@@ -0,0 +1,36 @@
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { sendPasswordResetEmail } from "../../../lib/auth-email-service";
+import { logger } from "@lastbrain/core";
+import { resolveSiteUrl } from "../../../lib/site-url";
+function extractLocale(request) {
+    const lang = request.headers
+        .get("accept-language")
+        ?.split(",")?.[0]
+        ?.split("-")?.[0];
+    return lang === "fr" || lang === "en" ? lang : undefined;
+}
+const DEFAULT_LOCALE = "fr";
+export async function POST(request) {
+    try {
+        const locale = extractLocale(request);
+        const supabase = await getSupabaseServerClient();
+        const { data: { user }, error, } = await supabase.auth.getUser();
+        if (error || !user) {
+            return NextResponse.json({ error: "Non authentifié" }, { status: 401 });
+        }
+        const resolvedLocale = locale || DEFAULT_LOCALE;
+        await sendPasswordResetEmail({
+            email: user.email || "",
+            displayName: user.user_metadata?.full_name,
+            ownerId: user.id,
+            redirectTo: `${resolveSiteUrl(request)}/${resolvedLocale}/reset-password`,
+            locale,
+        });
+        return NextResponse.json({ message: "Lien de réinitialisation envoyé" });
+    }
+    catch (err) {
+        logger.error("account reset-password error:", err);
+        return NextResponse.json({ error: "Impossible d'envoyer le lien de réinitialisation" }, { status: 500 });
+    }
+}

package/dist/api/auth/check-username.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Check username availability
+ * GET /api/auth/check-username?username=xxx&owner_id=xxx
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function GET(req: NextRequest): Promise<NextResponse<{
+    available: boolean;
+}>>;
+//# sourceMappingURL=check-username.d.ts.map

package/dist/api/auth/check-username.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-username.d.ts","sourceRoot":"","sources":["../../../src/api/auth/check-username.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGxD,wBAAsB,GAAG,CAAC,GAAG,EAAE,WAAW;;IA2CzC"}

package/dist/api/auth/check-username.js

@@ -0,0 +1,35 @@
+/**
+ * Check username availability
+ * GET /api/auth/check-username?username=xxx&owner_id=xxx
+ */
+import { NextResponse } from "next/server";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+export async function GET(req) {
+    try {
+        const { searchParams } = new URL(req.url);
+        const username = searchParams.get("username");
+        const owner_id = searchParams.get("owner_id");
+        if (!username) {
+            return NextResponse.json({ available: false, error: "Username required" }, { status: 400 });
+        }
+        const supabase = getSupabaseServiceClient();
+        // Check if username exists (case-insensitive), excluding current user
+        let query = supabase
+            .from("user_profil")
+            .select("username")
+            .ilike("username", username)
+            .limit(1);
+        if (owner_id) {
+            query = query.neq("owner_id", owner_id);
+        }
+        const { data, error } = await query;
+        if (error) {
+            return NextResponse.json({ available: false, error: error.message }, { status: 500 });
+        }
+        return NextResponse.json({ available: !data || data.length === 0 });
+    }
+    catch (error) {
+        console.error("[check-username] Error:", error);
+        return NextResponse.json({ available: false, error: "Internal server error" }, { status: 500 });
+    }
+}

package/dist/api/auth/establish-session.d.ts

@@ -0,0 +1,2 @@
+export declare function POST(request: Request): Promise<Response>;
+//# sourceMappingURL=establish-session.d.ts.map

package/dist/api/auth/establish-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"establish-session.d.ts","sourceRoot":"","sources":["../../../src/api/auth/establish-session.ts"],"names":[],"mappings":"AAOA,wBAAsB,IAAI,CAAC,OAAO,EAAE,OAAO,qBAwB1C"}

package/dist/api/auth/establish-session.js

@@ -0,0 +1,23 @@
+/**
+ * Establish server-side session with cookies
+ * Called after client-side setSession() to ensure HTTP-only cookies are set
+ */
+import { logger } from "@lastbrain/core";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+export async function POST(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        // Verify session exists on server
+        const { data: { user }, error: userError, } = await supabase.auth.getUser();
+        if (userError || !user) {
+            logger.error("❌ No user session on server:", userError);
+            return Response.json({ error: "Unauthorized" }, { status: 401 });
+        }
+        // Cookies are automatically set by Supabase middleware
+        return Response.json({ success: true, user: user.id });
+    }
+    catch (error) {
+        logger.debug("💥 Error establishing session:", error);
+        return Response.json({ error: "Failed to establish session" }, { status: 500 });
+    }
+}

package/dist/api/auth/me.d.ts

@@ -1,13 +1,13 @@
-import { NextResponse } from "next/server";
+import { NextResponse, type NextRequest } from "next/server";
 /**
  * GET /api/auth/me
  * Returns the current authenticated user and their profile
  */
-export declare function GET(): Promise<NextResponse<{
+export declare function GET(request: NextRequest): Promise<NextResponse<{
     data: {
-        id: string;
+        id: string | undefined;
         email: string | undefined;
-        created_at: string;
+        created_at: string | undefined;
         profile: any;
     };
 }> | NextResponse<{

package/dist/api/auth/me.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"me.d.ts","sourceRoot":"","sources":["../../../src/api/auth/me.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C;;;GAGG;AACH,wBAAsB,GAAG;;;;;;;;;;IAiCxB"}
+{"version":3,"file":"me.d.ts","sourceRoot":"","sources":["../../../src/api/auth/me.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAI7D;;;GAGG;AACH,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;IAsD7C"}

package/dist/api/auth/me.js

@@ -1,10 +1,11 @@
 import { NextResponse } from "next/server";
 import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
 /**
  * GET /api/auth/me
  * Returns the current authenticated user and their profile
  */
-export async function GET() {
+export async function GET(request) {
     try {
         const supabase = await getSupabaseServerClient();
         // Get the authenticated user
@@ -14,19 +15,40 @@ export async function GET() {
         const { data: profile } = await supabase
             .from("user_profil")
             .select("*")
-            .eq("owner_id", user.id)
+            .eq("owner_id", user?.id)
             .single();
         // Profile might not exist yet, that's OK
         const userData = {
-            id: user.id,
-            email: user.email,
-            created_at: user.created_at,
+            id: user?.id,
+            email: user?.email,
+            created_at: user?.created_at,
             profile: profile || null,
         };
+        // Si le client a envoyé un cookie NEXT_LOCALE, synchroniser sa valeur
+        // avec la langue du profil (si présente). Ne rien créer si le cookie
+        // est absent. Si la langue diffère, renvoyer une réponse JSON indiquant
+        // le changement de langue et définir le cookie côté serveur. Le client
+        // effectuera ensuite la redirection côté client pour éviter que fetch
+        // suive automatiquement un redirect 302.
+        try {
+            // Return localeUpdated to let the client/realtime decide what to do.
+            const cookieLang = request.cookies.get("NEXT_LOCALE")?.value;
+            const profileLang = profile?.language;
+            if (cookieLang && profileLang && profileLang !== cookieLang) {
+                return NextResponse.json({
+                    data: userData,
+                    localeUpdated: true,
+                    profileLang,
+                });
+            }
+        }
+        catch (e) {
+            logger.debug("me: locale sync error", e);
+        }
         return NextResponse.json({ data: userData });
     }
     catch (error) {
-        console.error("Error fetching user:", error);
+        logger.error("Error fetching user:", error);
         return NextResponse.json({ error: "Internal Server Error", message: "Failed to fetch user data" }, { status: 500 });
     }
 }

package/dist/api/auth/profile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../../src/api/auth/profile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGxD;;;GAGG;AACH,wBAAsB,GAAG;;;;;IA+BxB;AAED;;;GAGG;AACH,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;IAyF7C;AAED;;;GAGG;AACH,wBAAsB,KAAK,CAAC,OAAO,EAAE,WAAW;;;;;IAE/C"}
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../../src/api/auth/profile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIxD;;;GAGG;AACH,wBAAsB,GAAG;;;;;IA+BxB;AAED;;;GAGG;AACH,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;IA4F7C;AAED;;;GAGG;AACH,wBAAsB,KAAK,CAAC,OAAO,EAAE,WAAW;;;;;IAE/C"}

package/dist/api/auth/profile.js

@@ -1,5 +1,6 @@
 import { NextResponse } from "next/server";
 import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
 /**
  * GET /api/auth/profile
  * Returns the user's profile
@@ -21,7 +22,7 @@ export async function GET() {
         return NextResponse.json({ data: profile || null });
     }
     catch (error) {
-        console.error("Error fetching profile:", error);
+        logger.error("Error fetching profile:", error);
         return NextResponse.json({ error: "Internal Server Error", message: "Failed to fetch profile" }, { status: 500 });
     }
 }
@@ -35,7 +36,7 @@ export async function PUT(request) {
         const { data: { user }, } = await supabase.auth.getUser();
         // L'utilisateur est déjà authentifié grâce au middleware
         const body = await request.json();
-        const { first_name, last_name, avatar_url, bio, phone, company, website, location, language, timezone, preferences, } = body;
+        const { first_name, last_name, avatar_url, bio, phone, company, website, location, language, timezone, username, preferences, } = body;
         // Check if profile exists
         const { data: existingProfile } = await supabase
             .from("user_profil")
@@ -59,6 +60,7 @@ export async function PUT(request) {
                 language,
                 timezone,
                 preferences,
+                username,
             })
                 .eq("owner_id", user.id)
                 .select()
@@ -88,10 +90,11 @@ export async function PUT(request) {
         if (result.error) {
             return NextResponse.json({ error: "Database Error", message: result.error.message }, { status: 500 });
         }
+        // Indiquer au client si la langue a été modifiée (sans toucher aux cookies)
         return NextResponse.json({ data: result.data });
     }
     catch (error) {
-        console.error("Error updating profile:", error);
+        logger.error("Error updating profile:", error);
         return NextResponse.json({ error: "Internal Server Error", message: "Failed to update profile" }, { status: 500 });
     }
 }

package/dist/api/auth/storage/recalculate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * POST /api/auth/storage/recalculate
+ * Force recalculation of user storage quota from addons
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare const runtime = "nodejs";
+export declare const dynamic = "force-dynamic";
+export declare function POST(request: NextRequest): Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    success: boolean;
+    storage_quota_gb: any;
+    breakdown: any;
+}>>;
+//# sourceMappingURL=recalculate.d.ts.map

package/dist/api/auth/storage/recalculate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recalculate.d.ts","sourceRoot":"","sources":["../../../../src/api/auth/storage/recalculate.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIxD,eAAO,MAAM,OAAO,WAAW,CAAC;AAChC,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAEvC,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;IA+F9C"}

package/dist/api/auth/storage/recalculate.js

@@ -0,0 +1,68 @@
+/**
+ * POST /api/auth/storage/recalculate
+ * Force recalculation of user storage quota from addons
+ */
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+export async function POST(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        // Get authenticated user
+        const { data: { user }, error: authError, } = await supabase.auth.getUser();
+        if (authError || !user) {
+            return NextResponse.json({ error: "Non authentifié" }, { status: 401 });
+        }
+        logger.debug(`[Storage Recalculate] Recalculating for user ${user.id}`);
+        // Call get_user_limits RPC
+        const { data: limitsData, error: limitsError } = await supabase.rpc("get_user_limits", {
+            owner_id_param: user.id,
+        });
+        if (limitsError) {
+            logger.error("[Storage Recalculate] Error calling get_user_limits:", limitsError);
+            return NextResponse.json({ error: "Erreur lors du calcul des limites" }, { status: 500 });
+        }
+        logger.debug(`[Storage Recalculate] get_user_limits result:`, limitsData);
+        // Parse result (could be string or object)
+        let parsedLimits = limitsData;
+        if (typeof limitsData === "string") {
+            try {
+                parsedLimits = JSON.parse(limitsData);
+            }
+            catch (e) {
+                logger.error("[Storage Recalculate] Failed to parse limits data:", e);
+            }
+        }
+        const totalStorageGb = parsedLimits?.storage_quota_gb;
+        if (totalStorageGb !== null && totalStorageGb !== undefined) {
+            // Update user_profil
+            const { error: updateError } = await supabase.from("user_profil").upsert({
+                owner_id: user.id,
+                stockage: totalStorageGb,
+                updated_at: new Date().toISOString(),
+            }, {
+                onConflict: "owner_id",
+            });
+            if (updateError) {
+                logger.error("[Storage Recalculate] Error updating user_profil:", updateError);
+                return NextResponse.json({ error: "Erreur lors de la mise à jour" }, { status: 500 });
+            }
+            logger.info(`[Storage Recalculate] Updated user_profil.stockage to ${totalStorageGb} GB for user ${user.id}`);
+            return NextResponse.json({
+                success: true,
+                storage_quota_gb: totalStorageGb,
+                breakdown: parsedLimits?.storage_breakdown,
+            });
+        }
+        else {
+            logger.error("[Storage Recalculate] get_user_limits returned null for storage_quota_gb");
+            return NextResponse.json({ error: "Calcul invalide" }, { status: 500 });
+        }
+    }
+    catch (error) {
+        logger.error("[Storage Recalculate] Error:", error);
+        return NextResponse.json({ error: "Erreur lors du recalcul" }, { status: 500 });
+    }
+}

package/dist/api/auth/storage/usage.d.ts

@@ -0,0 +1,10 @@
+import { NextRequest, NextResponse } from "next/server";
+import { StorageUsageData } from "@lastbrain/core";
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    success: boolean;
+    error: string;
+}> | NextResponse<{
+    success: boolean;
+    data: StorageUsageData;
+}>>;
+//# sourceMappingURL=usage.d.ts.map

package/dist/api/auth/storage/usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../../../../src/api/auth/storage/usage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAExD,OAAO,EAAmB,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAqBpE,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;IAyF7C"}

package/dist/api/auth/storage/usage.js

@@ -0,0 +1,86 @@
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { getStorageUsage } from "@lastbrain/core";
+const storageCache = new Map();
+const CACHE_TTL = 5 * 60 * 1000; // 5 minutes en millisecondes
+// Nettoyer le cache périodiquement
+function cleanExpiredCache() {
+    const now = Date.now();
+    for (const [key, entry] of storageCache.entries()) {
+        if (now - entry.timestamp > CACHE_TTL) {
+            storageCache.delete(key);
+        }
+    }
+}
+export async function GET(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        // Vérifier l'authentification
+        const { data: { user }, error: authError, } = await supabase.auth.getUser();
+        if (authError || !user) {
+            return NextResponse.json({ success: false, error: "Non authentifié" }, { status: 401 });
+        }
+        // Route auth: uniquement les données de l'utilisateur connecté
+        const ownerId = user.id;
+        const { searchParams } = new URL(request.url);
+        const forceRefresh = searchParams.get("forceRefresh") === "true";
+        // Nettoyer le cache avant utilisation
+        cleanExpiredCache();
+        // Vérifier si on a des données en cache (sauf si forceRefresh)
+        const cacheKey = `storage-${ownerId}`;
+        let shouldUseCache = false;
+        if (!forceRefresh) {
+            const cachedEntry = storageCache.get(cacheKey);
+            const now = Date.now();
+            if (cachedEntry && now - cachedEntry.timestamp < CACHE_TTL) {
+                // Vérifier d'abord si l'allocation de stockage a changé
+                // Récupérer juste l'allocation depuis la base (requête légère)
+                const { data: userProfile } = await supabase
+                    .from("user_profil")
+                    .select("stockage")
+                    .eq("owner_id", ownerId)
+                    .single();
+                const currentAllocatedGb = userProfile?.stockage || 2.0;
+                const cachedAllocatedGb = cachedEntry.data.allocatedGb;
+                // Si l'allocation n'a pas changé, utiliser le cache
+                if (currentAllocatedGb === cachedAllocatedGb) {
+                    shouldUseCache = true;
+                }
+                else {
+                    // L'allocation a changé, invalider le cache
+                    storageCache.delete(cacheKey);
+                }
+            }
+            if (shouldUseCache && cachedEntry) {
+                // Retourner les données depuis le cache
+                return NextResponse.json({
+                    success: true,
+                    data: cachedEntry.data,
+                    cached: true,
+                });
+            }
+        }
+        else {
+            // Forcer la suppression du cache pour cet utilisateur
+            storageCache.delete(cacheKey);
+        }
+        // Récupérer les données d'usage de stockage
+        const storageData = await getStorageUsage(supabase, ownerId);
+        // Mettre en cache
+        storageCache.set(cacheKey, {
+            data: storageData,
+            timestamp: Date.now(),
+        });
+        return NextResponse.json({
+            success: true,
+            data: storageData,
+        });
+    }
+    catch (error) {
+        console.error("Erreur API storage usage:", error);
+        return NextResponse.json({
+            success: false,
+            error: error instanceof Error ? error.message : "Erreur serveur",
+        }, { status: 500 });
+    }
+}

package/dist/api/public/add-welcome-bonus.d.ts

@@ -0,0 +1,16 @@
+import { NextRequest, NextResponse } from "next/server";
+/**
+ * POST /api/public/add-welcome-bonus
+ * Adds welcome bonus tokens and notifications after email confirmation
+ * Called from the confirm page after successful session establishment
+ */
+export declare function POST(request: NextRequest): Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    message: string;
+    alreadyExists: boolean;
+}> | NextResponse<{
+    success: boolean;
+    message: string;
+}>>;
+//# sourceMappingURL=add-welcome-bonus.d.ts.map

package/dist/api/public/add-welcome-bonus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-welcome-bonus.d.ts","sourceRoot":"","sources":["../../../src/api/public/add-welcome-bonus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAQxD;;;;GAIG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;;;IAuN9C"}

package/dist/api/public/add-welcome-bonus.js

@@ -0,0 +1,177 @@
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient, getSupabaseServiceClient, } from "@lastbrain/core/server";
+import { sendWelcomeOnboardingEmail } from "../../lib/auth-email-service";
+import { logger } from "@lastbrain/core";
+/**
+ * POST /api/public/add-welcome-bonus
+ * Adds welcome bonus tokens and notifications after email confirmation
+ * Called from the confirm page after successful session establishment
+ */
+export async function POST(request) {
+    try {
+        // Get authenticated user from cookies
+        const supabase = await getSupabaseServerClient();
+        const { data: { user }, error: authError, } = await supabase.auth.getUser();
+        if (authError || !user?.id) {
+            return NextResponse.json({ error: "Not authenticated" }, { status: 401 });
+        }
+        // Use service client to bypass RLS for system operations
+        const serviceClient = await getSupabaseServiceClient();
+        logger.debug(`[add-welcome-bonus] Starting for user ${user.id} (${user.email})`);
+        // Check if signup bonus is enabled
+        const ENABLE_SIGNUP_BONUS = process.env.NEXT_PUBLIC_ENABLE_SIGNUP_BONUS === "true";
+        const SIGNUP_BONUS_AMOUNT_USD = parseFloat(process.env.NEXT_PUBLIC_SIGNUP_BONUS_AMOUNT_USD || "1.0");
+        if (!ENABLE_SIGNUP_BONUS) {
+            logger.debug(`[add-welcome-bonus] Signup bonus disabled for user ${user.id}`);
+            return NextResponse.json({
+                message: "Signup bonus disabled",
+                alreadyExists: false,
+            });
+        }
+        // Check if we already added bonus for this user
+        const { data: existingBonus } = await serviceClient
+            .from("user_token_ledger")
+            .select("id")
+            .eq("owner_id", user.id)
+            .eq("type", "signup_bonus")
+            .single();
+        // If bonus already exists, skip
+        if (existingBonus) {
+            logger.debug(`⏭️  Bonus already exists for user ${user.id}, skipping...`);
+            return NextResponse.json({
+                message: "Bonus already added",
+                alreadyExists: true,
+            });
+        }
+        // Add welcome bonus using wallet system
+        const MARGIN_TARGET = 0.6;
+        const providerBudgetUsd = SIGNUP_BONUS_AMOUNT_USD * (1 - MARGIN_TARGET); // 40%
+        // Insert into ledger with USD values
+        const { error: ledgerError } = await serviceClient
+            .from("user_token_ledger")
+            .insert({
+            owner_id: user.id,
+            type: "signup_bonus",
+            amount: 0, // Tokens deprecated
+            sell_value_added_usd: SIGNUP_BONUS_AMOUNT_USD,
+            provider_budget_added_usd: providerBudgetUsd,
+            meta: {
+                reason: "signup_welcome_bonus",
+                provider: "system",
+            },
+            created_by: null,
+        });
+        if (ledgerError) {
+            logger.error("Error adding welcome bonus to ledger:", ledgerError);
+            return NextResponse.json({ error: "Failed to add bonus" }, { status: 500 });
+        }
+        // Update wallet table
+        const { data: currentWallet } = await serviceClient
+            .from("user_token_wallet")
+            .select("wallet_provider_budget_usd, wallet_sell_value_usd")
+            .eq("user_id", user.id)
+            .single();
+        const newProviderBudget = (currentWallet?.wallet_provider_budget_usd || 0) + providerBudgetUsd;
+        const newSellValue = (currentWallet?.wallet_sell_value_usd || 0) + SIGNUP_BONUS_AMOUNT_USD;
+        const { error: walletError } = await serviceClient
+            .from("user_token_wallet")
+            .upsert({
+            user_id: user.id,
+            wallet_provider_budget_usd: newProviderBudget,
+            wallet_sell_value_usd: newSellValue,
+            updated_at: new Date().toISOString(),
+        }, {
+            onConflict: "user_id",
+        });
+        if (walletError) {
+            logger.error("Error updating wallet for welcome bonus:", walletError);
+            return NextResponse.json({ error: "Failed to update wallet" }, { status: 500 });
+        }
+        logger.debug(`✅ Added $${SIGNUP_BONUS_AMOUNT_USD} welcome bonus to user ${user.id}`);
+        // Determine locale: prefer cookie set by the client (NEXT_LOCALE),
+        // then user metadata, then Accept-Language header, fallback to 'en'.
+        let locale = "en";
+        try {
+            const cookieLocale = request.cookies.get("NEXT_LOCALE")?.value;
+            if (cookieLocale) {
+                locale = cookieLocale;
+            }
+            else if (user.user_metadata?.locale) {
+                locale = user.user_metadata.locale;
+            }
+            else {
+                const accept = request.headers.get("accept-language");
+                if (accept) {
+                    // take first language tag, e.g. 'fr-FR,fr;q=0.9' -> 'fr'
+                    const first = accept.split(",")[0].split("-")[0];
+                    if (first)
+                        locale = first;
+                }
+            }
+        }
+        catch (e) {
+            // if anything goes wrong, keep default 'en'
+            logger.warn("Could not determine locale from request, using default 'en'", e);
+        }
+        // Add welcome notifications only if bonus enabled
+        if (ENABLE_SIGNUP_BONUS && SIGNUP_BONUS_AMOUNT_USD > 0) {
+            const notifications = [
+                {
+                    title: locale === "fr" ? "Bienvenue ! 👋" : "Welcome! 👋",
+                    body: locale === "fr"
+                        ? "Merci de vous être inscrit ! Explorez toutes les fonctionnalités disponibles."
+                        : "Thank you for signing up! Explore all available features.",
+                    type: "primary",
+                },
+                {
+                    title: locale === "fr"
+                        ? `🎁 Cadeau de bienvenue : $${SIGNUP_BONUS_AMOUNT_USD}`
+                        : `🎁 Welcome gift: $${SIGNUP_BONUS_AMOUNT_USD}`,
+                    body: locale === "fr"
+                        ? `Nous vous offrons $${SIGNUP_BONUS_AMOUNT_USD} de crédit IA pour démarrer. Utilisez-les pour accéder à nos services premium.`
+                        : `We're giving you $${SIGNUP_BONUS_AMOUNT_USD} AI credits to get started. Use them to access our premium services.`,
+                    type: "success",
+                },
+            ];
+            for (const notification of notifications) {
+                const { error: notifError } = await serviceClient
+                    .from("user_notifications")
+                    .insert({
+                    owner_id: user.id,
+                    title: notification.title,
+                    body: notification.body,
+                    type: notification.type,
+                });
+                if (notifError) {
+                    logger.error("Error creating notification:", notifError);
+                }
+            }
+            logger.debug(`✅ Created welcome notifications for user ${user.id}`);
+        }
+        // Send welcome onboarding email with bonus amount if enabled
+        try {
+            await sendWelcomeOnboardingEmail({
+                email: user.email || "",
+                displayName: user.user_metadata?.full_name || "user",
+                locale,
+                ownerId: user.id,
+                bonusAmountUsd: ENABLE_SIGNUP_BONUS
+                    ? SIGNUP_BONUS_AMOUNT_USD
+                    : undefined,
+            });
+            logger.debug(`📧 Sent welcome onboarding email to ${user.email}`);
+        }
+        catch (emailError) {
+            logger.warn("Failed to send welcome email (non-blocking):", emailError);
+            // Don't fail the response if email fails
+        }
+        return NextResponse.json({
+            success: true,
+            message: "Welcome bonus added successfully",
+        });
+    }
+    catch (error) {
+        logger.error("Error in add-welcome-bonus:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

package/dist/api/public/callback.d.ts

@@ -0,0 +1,3 @@
+import { NextRequest, NextResponse } from "next/server";
+export declare function GET(request: NextRequest): Promise<NextResponse<unknown>>;
+//# sourceMappingURL=callback.d.ts.map

package/dist/api/public/callback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callback.d.ts","sourceRoot":"","sources":["../../../src/api/public/callback.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAWxD,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW,kCAuS7C"}