@lastbrain/ai-ui-react 1.0.37 → 1.0.39

package/src/context/LBAuthProvider.tsx

@@ -0,0 +1,269 @@
+"use client";
+
+/**
+ * Provider d'authentification LastBrain
+ * Gère l'état de connexion, la session et les appels IA
+ */
+
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useCallback,
+  useState,
+  type ReactNode,
+} from "react";
+import type {
+  LBAuthState,
+  LBApiKey,
+  LBSession,
+  LBLoginResult,
+  LBSessionResult,
+} from "@lastbrain/ai-ui-core";
+
+interface LBProviderProps {
+  children: ReactNode;
+  /** URL de l'API LastBrain (ex: https://api.lastbrain.io) */
+  baseUrl?: string;
+  /** URL du proxy local (ex: /api/lb) */
+  proxyUrl?: string;
+  /** Fonction appelée lors des changements d'état */
+  onStatusChange?: (status: LBAuthState["status"]) => void;
+}
+
+interface LBContextValue extends LBAuthState {
+  /** Fonction de connexion */
+  login: (email: string, password: string) => Promise<LBLoginResult>;
+  /** Fonction de déconnexion */
+  logout: () => Promise<void>;
+  /** Récupère les clés API de l'utilisateur */
+  fetchApiKeys: (accessToken: string) => Promise<LBApiKey[]>;
+  /** Sélectionne une clé API et crée une session */
+  selectApiKey: (accessToken: string, apiKeyId: string) => Promise<void>;
+  /** Recharge l'état de la session */
+  refreshSession: () => Promise<void>;
+  /** Clés API disponibles */
+  apiKeys: LBApiKey[];
+  /** Access token temporaire (après login) */
+  accessToken?: string;
+}
+
+const LBContext = createContext<LBContextValue | undefined>(undefined);
+
+export function LBProvider({
+  children,
+  baseUrl: _baseUrl = "/api/lb",
+  proxyUrl = "/api/lb",
+  onStatusChange,
+}: LBProviderProps) {
+  const [state, setState] = useState<LBAuthState>({
+    status: "loading",
+  });
+  const [apiKeys, setApiKeys] = useState<LBApiKey[]>([]);
+  const [accessToken, setAccessToken] = useState<string>();
+
+  /**
+   * Vérifie si une session existe au chargement
+   */
+  const checkSession = useCallback(async () => {
+    try {
+      const response = await fetch(`${proxyUrl}/auth/session/verify`, {
+        credentials: "include",
+      });
+
+      if (response.ok) {
+        const session: LBSession = await response.json();
+        setState({
+          status: "ready",
+          session,
+          user: {
+            id: session.userId,
+            email: "", // Sera rempli par une autre requête si nécessaire
+          },
+        });
+        onStatusChange?.("ready");
+      } else {
+        setState({ status: "needs_auth" });
+        onStatusChange?.("needs_auth");
+      }
+    } catch (error) {
+      console.error("[LBProvider] Session check failed:", error);
+      setState({ status: "needs_auth" });
+      onStatusChange?.("needs_auth");
+    }
+  }, [proxyUrl, onStatusChange]);
+
+  useEffect(() => {
+    checkSession();
+  }, [checkSession]);
+
+  /**
+   * Connexion utilisateur
+   */
+  const login = useCallback(
+    async (email: string, password: string): Promise<LBLoginResult> => {
+      try {
+        setState((prev: LBAuthState) => ({ ...prev, status: "loading" }));
+
+        const response = await fetch(`${proxyUrl}/auth/login`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ email, password }),
+          credentials: "include",
+        });
+
+        if (!response.ok) {
+          const error = await response.json();
+          throw new Error(error.message || "Login failed");
+        }
+
+        const result: LBLoginResult = await response.json();
+        setAccessToken(result.accessToken);
+
+        setState({
+          status: "ready",
+          user: result.user,
+        });
+
+        return result;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Login failed";
+        setState({
+          status: "error",
+          error: message,
+        });
+        throw error;
+      }
+    },
+    [proxyUrl]
+  );
+
+  /**
+   * Récupère les clés API de l'utilisateur
+   */
+  const fetchApiKeys = useCallback(
+    async (token: string): Promise<LBApiKey[]> => {
+      try {
+        const response = await fetch(`${proxyUrl}/user/api-keys`, {
+          headers: {
+            Authorization: `Bearer ${token}`,
+          },
+          credentials: "include",
+        });
+
+        if (!response.ok) {
+          throw new Error("Failed to fetch API keys");
+        }
+
+        const keys: LBApiKey[] = await response.json();
+        setApiKeys(keys);
+        return keys;
+      } catch (error) {
+        console.error("[LBProvider] Failed to fetch API keys:", error);
+        throw error;
+      }
+    },
+    [proxyUrl]
+  );
+
+  /**
+   * Sélectionne une clé API et crée une session
+   */
+  const selectApiKey = useCallback(
+    async (token: string, apiKeyId: string): Promise<void> => {
+      try {
+        setState((prev: LBAuthState) => ({ ...prev, status: "loading" }));
+
+        const response = await fetch(`${proxyUrl}/auth/session`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+          },
+          body: JSON.stringify({ api_key_id: apiKeyId }),
+          credentials: "include",
+        });
+
+        if (!response.ok) {
+          throw new Error("Failed to create session");
+        }
+
+        const sessionResult: LBSessionResult = await response.json();
+
+        setState({
+          status: "ready",
+          user: state.user,
+          selectedKey: sessionResult.apiKey,
+          session: {
+            sessionToken: sessionResult.sessionToken,
+            userId: state.user?.id || "",
+            apiKeyId,
+            expiresAt: Date.now() + sessionResult.expiresIn * 1000,
+          },
+        });
+
+        setAccessToken(undefined); // Nettoyer l'access token temporaire
+        onStatusChange?.("ready");
+      } catch (error) {
+        const message =
+          error instanceof Error ? error.message : "Failed to select API key";
+        setState({
+          status: "error",
+          error: message,
+        });
+        throw error;
+      }
+    },
+    [proxyUrl, state.user, onStatusChange]
+  );
+
+  /**
+   * Déconnexion
+   */
+  const logout = useCallback(async (): Promise<void> => {
+    try {
+      await fetch(`${proxyUrl}/auth/session/logout`, {
+        method: "POST",
+        credentials: "include",
+      });
+    } catch (error) {
+      console.error("[LBProvider] Logout failed:", error);
+    } finally {
+      setState({ status: "needs_auth" });
+      setApiKeys([]);
+      setAccessToken(undefined);
+      onStatusChange?.("needs_auth");
+    }
+  }, [proxyUrl, onStatusChange]);
+
+  /**
+   * Recharge la session
+   */
+  const refreshSession = useCallback(async (): Promise<void> => {
+    await checkSession();
+  }, [checkSession]);
+
+  const value: LBContextValue = {
+    ...state,
+    login,
+    logout,
+    fetchApiKeys,
+    selectApiKey,
+    refreshSession,
+    apiKeys,
+    accessToken,
+  };
+
+  return <LBContext.Provider value={value}>{children}</LBContext.Provider>;
+}
+
+/**
+ * Hook pour accéder au contexte LastBrain
+ */
+export function useLB(): LBContextValue {
+  const context = useContext(LBContext);
+  if (!context) {
+    throw new Error("useLB must be used within LBProvider");
+  }
+  return context;
+}

package/src/hooks/useAiModels.ts

@@ -87,8 +87,7 @@ export function useAiModels(options?: UseAiModelsOptions): UseAiModelsResult {
       filtered.length
     );
     return filtered;
-    return filtered;
-  }, [useContextData, context, options?.modelType]);
+  }, [useContextData, context, options]);
 
   const refetch = useCallback(() => {
     if (useContextData) {

package/src/hooks/useLB.ts

@@ -0,0 +1,7 @@
+"use client";
+
+/**
+ * Hook useLB - Export du hook depuis LBAuthProvider
+ */
+
+export { useLB } from "../context/LBAuthProvider";

package/src/hooks/usePrompts.ts

@@ -79,7 +79,10 @@ export function usePrompts(): UsePromptsReturn {
         // Check cache first (60 seconds TTL)
         const cached = getCached<Prompt[] | PublicPrompt[]>(cacheKey, 60000);
         if (cached) {
-          console.log("[usePrompts] Using cached data", cached.length);
+          console.log("[usePrompts] Using cached data:", {
+            count: cached.length,
+            prompts: cached,
+          });
           setPrompts(cached);
           setLoading(false);
           return;
@@ -141,6 +144,13 @@ export function usePrompts(): UsePromptsReturn {
 
         const data = await response.json();
 
+        console.log("[usePrompts] Server response:", {
+          ok: response.ok,
+          status: response.status,
+          promptsCount: data.prompts?.length || 0,
+          data,
+        });
+
         if (response.ok) {
           const promptsData = data.prompts || [];
           setPrompts(promptsData);
@@ -155,7 +165,7 @@ export function usePrompts(): UsePromptsReturn {
         setLoading(false);
       }
     },
-    [baseUrl]
+    [baseUrl, apiKeyId]
   );
 
   const createPrompt = useCallback(
@@ -314,7 +324,7 @@ export function usePrompts(): UsePromptsReturn {
           body: JSON.stringify({ prompt_id: promptId, stat_type: statType }),
           credentials: isExternalProxy ? "include" : "same-origin",
         });
-      } catch (err) {
+      } catch {
         // Silent fail for stats
       }
     },

package/src/index.ts

@@ -3,6 +3,7 @@ export * from "./types";
 
 // Context
 export * from "./context/AiProvider";
+export * from "./context/LBAuthProvider";
 
 // Hooks
 export * from "./hooks/useAiClient";
@@ -12,6 +13,7 @@ export * from "./hooks/useAiCallText";
 export * from "./hooks/useAiCallImage";
 export * from "./hooks/usePrompts";
 export * from "./hooks/useModelManagement";
+export * from "./hooks/useLB";
 
 // Components
 export * from "./components/AiPromptPanel";
@@ -24,6 +26,8 @@ export * from "./components/AiImageButton";
 export * from "./components/AiContextButton";
 export * from "./components/AiSettingsButton";
 export * from "./components/AiStatusButton";
+export * from "./components/LBConnectButton";
+export * from "./components/LBKeyPicker";
 
 // Toast system
 export * from "./components/ErrorToast";