@lastbrain/module-ai 0.1.18 → 0.1.19

package/dist/ai.build.config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ai.build.config.d.ts","sourceRoot":"","sources":["../src/ai.build.config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,QAAA,MAAM,WAAW,EAAE,iBAsGlB,CAAC;AAEF,eAAe,WAAW,CAAC"}
+{"version":3,"file":"ai.build.config.d.ts","sourceRoot":"","sources":["../src/ai.build.config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,QAAA,MAAM,WAAW,EAAE,iBAsKlB,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/dist/ai.build.config.js

@@ -11,6 +11,11 @@ const buildConfig = {
             path: "/user-token",
             componentExport: "UserTokenPage",
         },
+        {
+            section: "admin",
+            path: "/token-packs",
+            componentExport: "AdminTokenPacksPage",
+        },
     ],
     apis: [
         // Routes de génération IA
@@ -36,6 +41,50 @@ const buildConfig = {
             entryPoint: "api/auth/user-tokens",
             authRequired: true,
         },
+        // Token packs - User routes
+        {
+            method: "GET",
+            path: "/api/ai/auth/token-packs",
+            handlerExport: "GET",
+            entryPoint: "api/auth/token-packs",
+            authRequired: true,
+        },
+        {
+            method: "POST",
+            path: "/api/ai/auth/token-checkout",
+            handlerExport: "POST",
+            entryPoint: "api/auth/token-checkout",
+            authRequired: true,
+        },
+        // Token packs - Admin routes
+        {
+            method: "GET",
+            path: "/api/ai/admin/token-packs",
+            handlerExport: "GET",
+            entryPoint: "api/admin/token-packs",
+            authRequired: true,
+        },
+        {
+            method: "POST",
+            path: "/api/ai/admin/token-packs",
+            handlerExport: "POST",
+            entryPoint: "api/admin/token-packs",
+            authRequired: true,
+        },
+        {
+            method: "PUT",
+            path: "/api/ai/admin/token-packs/[id]",
+            handlerExport: "PUT",
+            entryPoint: "api/admin/token-packs/[id]",
+            authRequired: true,
+        },
+        {
+            method: "DELETE",
+            path: "/api/ai/admin/token-packs/[id]",
+            handlerExport: "DELETE",
+            entryPoint: "api/admin/token-packs/[id]",
+            authRequired: true,
+        },
         // Routes admin pour la gestion des tokens
         {
             method: "GET",
@@ -58,12 +107,20 @@ const buildConfig = {
             entryPoint: "api/admin/user-token/[id]",
             authRequired: true,
         },
+        // Webhook for token purchase payments
+        {
+            method: "POST",
+            path: "/api/ai/public/webhook",
+            handlerExport: "POST",
+            entryPoint: "api/public/webhook",
+            authRequired: false,
+        },
     ],
     migrations: {
         enabled: true,
         priority: 30,
         path: "supabase/migrations",
-        files: ["20251125000000_ai_tokens.sql"],
+        files: ["20251125000000_ai_tokens.sql", "20251201000000_token_packs.sql"],
         migrationsDownPath: "supabase/migrations-down",
     },
     menu: {
@@ -88,6 +145,13 @@ const buildConfig = {
                 shortcut: "cmd+shift+g",
                 shortcutDisplay: "⌘⇧G",
             },
+            {
+                title: "Packs de Tokens",
+                description: "Gestion des packs de tokens",
+                icon: "Package",
+                path: "/admin/ai/token-packs",
+                order: 101,
+            },
         ],
     },
     userTabs: [

package/dist/api/admin/token-packs/[id].d.ts

@@ -0,0 +1,28 @@
+import { NextRequest, NextResponse } from "next/server";
+/**
+ * PUT /api/ai/admin/token-packs/[id]
+ * Update a token pack
+ */
+export declare function PUT(request: NextRequest, context: {
+    params: Promise<{
+        id: string;
+    }>;
+}): Promise<NextResponse<{
+    data: any;
+}> | NextResponse<{
+    error: any;
+}>>;
+/**
+ * DELETE /api/ai/admin/token-packs/[id]
+ * Delete a token pack
+ */
+export declare function DELETE(request: NextRequest, context: {
+    params: Promise<{
+        id: string;
+    }>;
+}): Promise<NextResponse<{
+    success: boolean;
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=%5Bid%5D.d.ts.map

package/dist/api/admin/token-packs/[id].d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"[id].d.ts","sourceRoot":"","sources":["../../../../src/api/admin/token-packs/[id].ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAcxD;;;GAGG;AACH,wBAAsB,GAAG,CACvB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE;IAAE,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE;;;;IAwB7C;AAED;;;GAGG;AACH,wBAAsB,MAAM,CAC1B,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE;IAAE,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE;;;;IAkB7C"}

package/dist/api/admin/token-packs/[id].js

@@ -0,0 +1,44 @@
+import { NextResponse } from "next/server";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+/**
+ * PUT /api/ai/admin/token-packs/[id]
+ * Update a token pack
+ */
+export async function PUT(request, context) {
+    try {
+        const { id } = await context.params;
+        const supabase = await getSupabaseServiceClient();
+        const body = await request.json();
+        const { data, error } = await supabase
+            .from("token_packs")
+            .update(body)
+            .eq("id", id)
+            .select()
+            .single();
+        if (error)
+            throw error;
+        return NextResponse.json({ data }, { status: 200 });
+    }
+    catch (error) {
+        console.error("[Admin Token Packs] PUT error:", error);
+        return NextResponse.json({ error: error.message || "Erreur lors de la mise à jour du pack" }, { status: 500 });
+    }
+}
+/**
+ * DELETE /api/ai/admin/token-packs/[id]
+ * Delete a token pack
+ */
+export async function DELETE(request, context) {
+    try {
+        const { id } = await context.params;
+        const supabase = await getSupabaseServiceClient();
+        const { error } = await supabase.from("token_packs").delete().eq("id", id);
+        if (error)
+            throw error;
+        return NextResponse.json({ success: true }, { status: 200 });
+    }
+    catch (error) {
+        console.error("[Admin Token Packs] DELETE error:", error);
+        return NextResponse.json({ error: error.message || "Erreur lors de la suppression du pack" }, { status: 500 });
+    }
+}

package/dist/api/admin/token-packs.d.ts

@@ -0,0 +1,20 @@
+import { NextRequest, NextResponse } from "next/server";
+/**
+ * GET /api/ai/admin/token-packs
+ * List all token packs (including inactive)
+ */
+export declare function GET(): Promise<NextResponse<{
+    data: any[];
+}> | NextResponse<{
+    error: any;
+}>>;
+/**
+ * POST /api/ai/admin/token-packs
+ * Create a new token pack
+ */
+export declare function POST(request: NextRequest): Promise<NextResponse<{
+    data: any;
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=token-packs.d.ts.map

package/dist/api/admin/token-packs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-packs.d.ts","sourceRoot":"","sources":["../../../src/api/admin/token-packs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAexD;;;GAGG;AACH,wBAAsB,GAAG;;;;IAmBxB;AAED;;;GAGG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;IAgD9C"}

package/dist/api/admin/token-packs.js

@@ -0,0 +1,57 @@
+import { NextResponse } from "next/server";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+/**
+ * GET /api/ai/admin/token-packs
+ * List all token packs (including inactive)
+ */
+export async function GET() {
+    try {
+        const supabase = await getSupabaseServiceClient();
+        const { data, error } = await supabase
+            .from("token_packs")
+            .select("*")
+            .order("sort_order", { ascending: true });
+        if (error)
+            throw error;
+        return NextResponse.json({ data }, { status: 200 });
+    }
+    catch (error) {
+        console.error("[Admin Token Packs] GET error:", error);
+        return NextResponse.json({ error: error.message || "Erreur lors de la récupération des packs" }, { status: 500 });
+    }
+}
+/**
+ * POST /api/ai/admin/token-packs
+ * Create a new token pack
+ */
+export async function POST(request) {
+    try {
+        const supabase = await getSupabaseServiceClient();
+        const body = await request.json();
+        const { name, description, tokens, price_cents, currency, stripe_price_id, is_active, sort_order, } = body;
+        if (!name || !tokens || !price_cents || !currency) {
+            return NextResponse.json({ error: "Champs requis manquants" }, { status: 400 });
+        }
+        const { data, error } = await supabase
+            .from("token_packs")
+            .insert({
+            name,
+            description,
+            tokens,
+            price_cents,
+            currency,
+            stripe_price_id,
+            is_active: is_active ?? true,
+            sort_order: sort_order ?? 0,
+        })
+            .select()
+            .single();
+        if (error)
+            throw error;
+        return NextResponse.json({ data }, { status: 201 });
+    }
+    catch (error) {
+        console.error("[Admin Token Packs] POST error:", error);
+        return NextResponse.json({ error: error.message || "Erreur lors de la création du pack" }, { status: 500 });
+    }
+}

package/dist/api/admin/user-token.js

@@ -113,7 +113,8 @@ export async function POST(request) {
         }
         // Déterminer le type d'opération
         const operationType = type || (amount > 0 ? "adjust" : "adjust");
-        const result = await addTokens(userId, amount, operationType, { reason: reason || "Ajustement manuel par admin" }, undefined);
+        const result = await addTokens(userId, amount, operationType, { reason: reason || "Ajustement manuel par admin" }, undefined // created_by undefined pour les opérations admin via service role
+        );
         if (!result.success) {
             return NextResponse.json({ error: result.error }, { status: 500 });
         }

package/dist/api/auth/create-checkout.d.ts

@@ -0,0 +1,31 @@
+import { NextRequest, NextResponse } from "next/server";
+/**
+ * POST /api/ai/create-checkout
+ *
+ * Creates a Stripe checkout session for purchasing token packs.
+ *
+ * Body:
+ * - token_pack_id: string - ID of the token pack to purchase
+ *
+ * Returns:
+ * - url: string - Stripe checkout URL
+ * - sessionId: string - Stripe session ID
+ */
+export declare function POST(request: NextRequest): Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    url: string;
+    sessionId: string;
+    paymentId: string;
+}>>;
+/**
+ * GET /api/ai/create-checkout - Get available token packs
+ *
+ * Returns list of available token packs for purchase
+ */
+export declare function GET(): Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    packs: any[];
+}>>;
+//# sourceMappingURL=create-checkout.d.ts.map

package/dist/api/auth/create-checkout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-checkout.d.ts","sourceRoot":"","sources":["../../../src/api/auth/create-checkout.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGxD;;;;;;;;;;;GAWG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;IAuE9C;AAED;;;;GAIG;AACH,wBAAsB,GAAG;;;;IAuBxB"}

package/dist/api/auth/create-checkout.js

@@ -0,0 +1,93 @@
+// ============================================================================
+// POST /api/ai/create-checkout - Create Stripe checkout for token purchase
+// ============================================================================
+// SECURITY: Amount is looked up from token_packs table - NOT from client
+// ============================================================================
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+/**
+ * POST /api/ai/create-checkout
+ *
+ * Creates a Stripe checkout session for purchasing token packs.
+ *
+ * Body:
+ * - token_pack_id: string - ID of the token pack to purchase
+ *
+ * Returns:
+ * - url: string - Stripe checkout URL
+ * - sessionId: string - Stripe session ID
+ */
+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 });
+        }
+        // Parse request body
+        const body = await request.json();
+        const { token_pack_id } = body;
+        if (!token_pack_id) {
+            return NextResponse.json({ error: "token_pack_id est requis" }, { status: 400 });
+        }
+        // Validate environment
+        const frontendUrl = process.env.FRONTEND_URL || process.env.NEXT_PUBLIC_APP_URL;
+        if (!frontendUrl) {
+            console.error("FRONTEND_URL or NEXT_PUBLIC_APP_URL not set");
+            return NextResponse.json({ error: "Configuration serveur manquante" }, { status: 500 });
+        }
+        // Import central payment service dynamically to avoid circular deps
+        const { createOneTimeCheckout } = await import("@lastbrain-labs/module-core-payment-pro/server");
+        // Create checkout using central payment service
+        // Price is looked up server-side from token_packs table
+        const result = await createOneTimeCheckout({
+            purpose: "token",
+            module: "module-ai",
+            mode: "one_time",
+            owner_id: user.id,
+            user_id: user.id,
+            resourceType: "token_packs",
+            resourceId: token_pack_id,
+            successPath: "/auth/ai/token?success=true",
+            cancelPath: "/auth/ai/token?cancelled=true",
+            description: "Achat de tokens IA",
+        });
+        return NextResponse.json({
+            url: result.url,
+            sessionId: result.sessionId,
+            paymentId: result.paymentId,
+        });
+    }
+    catch (error) {
+        console.error("[POST /api/ai/create-checkout] Error:", error);
+        const message = error instanceof Error
+            ? error.message
+            : "Erreur lors de la création du paiement";
+        return NextResponse.json({ error: message }, { status: 500 });
+    }
+}
+/**
+ * GET /api/ai/create-checkout - Get available token packs
+ *
+ * Returns list of available token packs for purchase
+ */
+export async function GET() {
+    try {
+        const supabase = await getSupabaseServerClient();
+        const { data: packs, error } = await supabase
+            .from("token_packs")
+            .select("*")
+            .eq("is_active", true)
+            .order("sort_order", { ascending: true });
+        if (error) {
+            console.error("[GET /api/ai/create-checkout] Error:", error);
+            return NextResponse.json({ error: "Erreur lors de la récupération des packs" }, { status: 500 });
+        }
+        return NextResponse.json({ packs: packs || [] });
+    }
+    catch (error) {
+        console.error("[GET /api/ai/create-checkout] Error:", error);
+        return NextResponse.json({ error: "Erreur serveur" }, { status: 500 });
+    }
+}

package/dist/api/auth/generate-image.d.ts

@@ -1,11 +1,11 @@
 import { NextRequest, NextResponse } from "next/server";
 export declare function POST(request: NextRequest): Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
     imageUrl: string;
+    supabaseImageUrl: string | null;
     tokensUsed: number;
     tokensRemaining: number;
     model: "dall-e-3" | "dall-e-2";
-    cost: number;
-}> | NextResponse<{
-    error: any;
 }>>;
 //# sourceMappingURL=generate-image.d.ts.map

package/dist/api/auth/generate-image.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-image.d.ts","sourceRoot":"","sources":["../../../src/api/auth/generate-image.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAoCxD,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;;;IA4H9C"}
+{"version":3,"file":"generate-image.d.ts","sourceRoot":"","sources":["../../../src/api/auth/generate-image.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AA0CxD,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;;;IAyL9C"}

package/dist/api/auth/generate-image.js

@@ -17,55 +17,96 @@ const IMAGE_COSTS = {
     "dall-e-3-1792x1024-standard": 0.08,
     "dall-e-3-1792x1024-hd": 0.12,
 };
-// Équivalent en tokens (arbitraire pour notre système de comptage)
-const TOKENS_PER_IMAGE = {
-    "dall-e-2": 1000,
-    "dall-e-3-standard": 2000,
-    "dall-e-3-hd": 4000,
+// Coût en tokens par combinaison modèle/taille(/qualité)
+const TOKENS_PER_IMAGE_KEY = {
+    "dall-e-2-256x256": 3000,
+    "dall-e-2-512x512": 4000,
+    "dall-e-2-1024x1024": 5000,
+    "dall-e-3-1024x1024-standard": 6000,
+    "dall-e-3-1024x1024-hd": 8000,
+    "dall-e-3-1024x1792-standard": 8000,
+    "dall-e-3-1024x1792-hd": 10000,
+    "dall-e-3-1792x1024-standard": 8000,
+    "dall-e-3-1792x1024-hd": 10000,
 };
 export async function POST(request) {
     try {
         const supabase = await getSupabaseServerClient();
         // Vérifier l'authentification
         const { data: { user }, } = await supabase.auth.getUser();
+        if (!user) {
+            return NextResponse.json({ error: "Utilisateur non authentifié" }, { status: 401 });
+        }
         // L'utilisateur est déjà authentifié grâce au middleware
         const body = await request.json();
-        const { prompt, model = "dall-e-3", size = "1024x1024", quality = "standard", } = body;
+        const { prompt, model = "dall-e-3", size = "1024x1024", quality = "standard", uploadPath, } = body;
         if (!prompt) {
             return NextResponse.json({ error: "Le prompt est requis" }, { status: 400 });
         }
         // Calculer le coût et les tokens
         const costKey = model === "dall-e-3" ? `${model}-${size}-${quality}` : `${model}-${size}`;
         const cost = IMAGE_COSTS[costKey] || 0.04;
-        const tokenKey = model === "dall-e-3" ? `${model}-${quality}` : model;
-        const tokensRequired = TOKENS_PER_IMAGE[tokenKey] || 1000;
+        const tokensRequired = TOKENS_PER_IMAGE_KEY[costKey] ?? 6000; // fallback safe
         // Vérifier le solde de tokens
         const currentBalance = await getTokenBalance(user.id);
-        if (currentBalance < tokensRequired) {
+        // Autoriser la génération tant que le solde est positif, même si la déduction rend le solde négatif
+        if (currentBalance <= 0) {
             return NextResponse.json({
-                error: `Solde insuffisant. Disponible: ${currentBalance}, requis: ${tokensRequired}`,
+                error: "Solde insuffisant. Votre solde de tokens est nul ou négatif.",
             }, { status: 402 });
         }
-        // Paramètres pour DALL-E 3
-        const imageParams = {
-            model,
-            prompt,
-            n: 1,
-            response_format: "url",
-        };
-        // DALL-E 3 a des paramètres différents de DALL-E 2
+        let imageParams;
         if (model === "dall-e-3") {
-            imageParams.size = size;
-            imageParams.quality = quality;
+            imageParams = {
+                model: "dall-e-3",
+                prompt,
+                n: 1,
+                response_format: "url",
+                size: size,
+                quality: quality,
+            };
         }
         else {
-            // DALL-E 2 ne supporte que certaines tailles
+            // DALL-E 2
             const validSizes = ["256x256", "512x512", "1024x1024"];
-            imageParams.size = validSizes.includes(size) ? size : "1024x1024";
+            imageParams = {
+                model: "dall-e-2",
+                prompt,
+                n: 1,
+                response_format: "url",
+                size: validSizes.includes(size)
+                    ? size
+                    : "1024x1024",
+            };
         }
         // Appeler OpenAI
         const response = await openai.images.generate(imageParams);
         const imageUrl = response.data?.[0]?.url;
+        let supabaseImageUrl = null;
+        if (imageUrl && uploadPath) {
+            // Générer un nom de fichier si uploadPath se termine par '/'
+            let finalPath = uploadPath;
+            if (uploadPath.endsWith("/")) {
+                const ext = (imageUrl.split(".").pop() || "png").split("?")[0];
+                const filename = `recipe-${Date.now()}.${ext}`;
+                finalPath = uploadPath + filename;
+            }
+            // 1. Télécharger l'image depuis OpenAI
+            const imageRes = await fetch(imageUrl);
+            if (!imageRes.ok)
+                throw new Error("Erreur lors du téléchargement de l'image OpenAI");
+            const arrayBuffer = await imageRes.arrayBuffer();
+            const contentType = imageRes.headers.get("content-type") || "image/png";
+            // 2. Uploader dans Supabase Storage (bucket à adapter si besoin)
+            const bucket = finalPath.split("/")[0] || "app";
+            const { error: uploadError } = await supabase.storage
+                .from(bucket)
+                .upload(finalPath.split("/").slice(1).join("/"), new Uint8Array(arrayBuffer), { contentType, upsert: true });
+            if (uploadError)
+                throw new Error("Erreur upload Supabase: " + uploadError.message);
+            // 3. Générer l'URL publique
+            supabaseImageUrl = finalPath;
+        }
         if (!imageUrl) {
             throw new Error("Aucune image générée");
         }
@@ -83,20 +124,20 @@ export async function POST(request) {
         }
         return NextResponse.json({
             imageUrl,
+            supabaseImageUrl,
             tokensUsed: tokensRequired,
             tokensRemaining: tokenResult.balance,
             model,
-            cost,
         });
     }
     catch (error) {
-        console.error("Erreur de génération d'image:", error);
-        if (error.code === "insufficient_quota") {
+        const err = error;
+        if (err.code === "insufficient_quota") {
             return NextResponse.json({ error: "Quota OpenAI dépassé. Contactez l'administrateur." }, { status: 503 });
         }
-        if (error.code === "content_policy_violation") {
+        if (err.code === "content_policy_violation") {
             return NextResponse.json({ error: "Le prompt viole la politique de contenu d'OpenAI." }, { status: 400 });
         }
-        return NextResponse.json({ error: error.message || "Erreur lors de la génération de l'image" }, { status: 500 });
+        return NextResponse.json({ error: err.message || "Erreur lors de la génération de l'image" }, { status: 500 });
     }
 }

package/dist/api/auth/token-checkout.d.ts

@@ -0,0 +1,12 @@
+import { NextRequest, NextResponse } from "next/server";
+/**
+ * POST /api/ai/auth/token-checkout
+ * Create a Stripe checkout session for token purchase
+ */
+export declare function POST(request: NextRequest): Promise<NextResponse<{
+    checkout_url: any;
+    session_id: any;
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=token-checkout.d.ts.map

package/dist/api/auth/token-checkout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-checkout.d.ts","sourceRoot":"","sources":["../../../src/api/auth/token-checkout.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAMxD;;;GAGG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;IAgG9C"}

package/dist/api/auth/token-checkout.js

@@ -0,0 +1,79 @@
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient, fetchInternalApi, } from "@lastbrain/core/server";
+/**
+ * POST /api/ai/auth/token-checkout
+ * Create a Stripe checkout session for token purchase
+ */
+export async function POST(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        // Verify authentication
+        const { data: { user }, } = await supabase.auth.getUser();
+        if (!user) {
+            return NextResponse.json({ error: "Non authentifié" }, { status: 401 });
+        }
+        const body = await request.json();
+        const { pack_id } = body;
+        if (!pack_id) {
+            return NextResponse.json({ error: "Pack ID requis" }, { status: 400 });
+        }
+        // Get token pack details
+        const { data: pack, error: packError } = await supabase
+            .from("token_packs")
+            .select("*")
+            .eq("id", pack_id)
+            .eq("is_active", true)
+            .single();
+        if (packError || !pack) {
+            return NextResponse.json({ error: "Pack non trouvé" }, { status: 404 });
+        }
+        const baseUrl = process.env.APP_PRINCIPAL_DOMAIN ||
+            process.env.NEXT_PUBLIC_APP_URL ||
+            "http://localhost:3000";
+        const successUrl = `${baseUrl}${"/cart/success"}`;
+        const cancelUrl = `${baseUrl}${"/cart/cancel"}`;
+        // Create checkout session via payment API
+        const checkoutResponse = await fetchInternalApi("/api/auth/payment/checkout", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                items: [
+                    {
+                        name: pack.name,
+                        description: pack.description || `${pack.tokens} tokens`,
+                        price_cents: pack.price_cents,
+                        quantity: 1,
+                    },
+                ],
+                currency: pack.currency,
+                mode: "one_time",
+                success_url: successUrl,
+                cancel_url: cancelUrl,
+                metadata: {
+                    purpose: "token_purchase",
+                    module: "@lastbrain-labs/module-ai",
+                    token_pack_id: pack.id,
+                    tokens_amount: pack.tokens.toString(),
+                    user_id: user.id,
+                },
+            }),
+        }, request);
+        if (!checkoutResponse.ok) {
+            const error = await checkoutResponse.json();
+            throw new Error(error.error || "Erreur lors de la création du checkout");
+        }
+        const checkoutData = await checkoutResponse.json();
+        const url = checkoutData.url || checkoutData.checkoutUrl || checkoutData.checkout_url;
+        const sessionId = checkoutData.session_id || checkoutData.sessionId;
+        return NextResponse.json({
+            checkout_url: url,
+            session_id: sessionId,
+        }, { status: 200 });
+    }
+    catch (error) {
+        console.error("[Token Checkout] Error:", error);
+        return NextResponse.json({ error: error.message || "Erreur lors du checkout" }, { status: 500 });
+    }
+}