@robosystems/core 0.3.0

package/auth-components/AuthProvider.js

@@ -0,0 +1,565 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useRef, useState, } from 'react';
+import { clearEntitySelection } from '../actions/entity-actions';
+import { clearGraphSelection } from '../actions/graph-actions';
+import { performLogoutCleanup } from '../auth-core/cleanup';
+import { RoboSystemsAuthClient } from '../auth-core/client';
+import { useTokenExpiryHandler } from '../auth-core/hooks';
+import { getTimeUntilExpiry, getTokenStatus } from '../auth-core/token-storage';
+// Configuration constants
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+const TOKEN_REFRESH_INTERVAL_MS = 25 * 60 * 1000; // 25 minutes (5 min before 30 min expiry)
+const TOKEN_WARNING_CHECK_INTERVAL_MS = 30 * 1000; // 30 seconds - reduced for better battery life
+const ACTIVITY_THROTTLE_MS = 1000; // 1 second
+const HEARTBEAT_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes - server validation heartbeat
+const REFRESH_COOLDOWN_MS = 60 * 1000; // 60 seconds - prevent duplicate background refreshes
+const LOGOUT_TIMEOUT_MS = 10 * 1000; // 10 seconds - timeout for logout operation
+const CACHE_VERSION = '1'; // Increment to invalidate all cached auth data
+// Debug logging helper
+const debugLog = (message, error) => {
+    if (process.env.NODE_ENV === 'development') {
+        console.debug(`[AuthProvider] ${message}`, error);
+    }
+};
+// Storage error logging helper - logs to console.error for production visibility
+const logStorageError = (operation, error) => {
+    const message = `[AuthProvider] Storage ${operation} failed - continuing with degraded UX`;
+    if (process.env.NODE_ENV === 'development') {
+        console.debug(message, error);
+    }
+    else {
+        // In production, log to console.error so errors are visible in monitoring
+        console.error(message, error);
+    }
+};
+const AuthContext = createContext(null);
+export function AuthProvider({ children, apiUrl = process.env.NEXT_PUBLIC_ROBOSYSTEMS_API_URL ||
+    'http://localhost:8000', }) {
+    const [user, setUser] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const [sessionWarning, setSessionWarning] = useState({ show: false, timeLeft: 0 });
+    const [authClient] = useState(() => new RoboSystemsAuthClient(apiUrl));
+    const lastActivity = useRef(Date.now());
+    const mounted = useRef(true);
+    const activityTimeoutRef = useRef(null);
+    const lastRefreshAttempt = useRef(0);
+    const refreshInProgress = useRef(false);
+    const isAuthenticated = user !== null;
+    const validateCachedUser = useCallback(async (userData) => {
+        try {
+            const user = await authClient.getCurrentUser();
+            if (user.id !== userData.id) {
+                // Cache is stale, update with fresh data
+                setUser(user);
+                if (typeof window !== 'undefined') {
+                    try {
+                        sessionStorage.setItem('auth_user_cache', JSON.stringify(Object.assign(Object.assign({}, user), { cached_at: Date.now(), cache_version: CACHE_VERSION })));
+                    }
+                    catch (error) {
+                        // Storage error - continue without caching (graceful degradation)
+                        logStorageError('write', error);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // User not authenticated anymore, clear cache
+            setUser(null);
+            if (typeof window !== 'undefined') {
+                try {
+                    sessionStorage.removeItem('auth_user_cache');
+                }
+                catch (error) {
+                    // Storage error - continue with graceful degradation
+                    logStorageError('remove', error);
+                }
+            }
+        }
+    }, [authClient]);
+    const checkSession = useCallback(async () => {
+        try {
+            const user = await authClient.getCurrentUser();
+            setUser(user);
+            // Cache the user data
+            if (typeof window !== 'undefined') {
+                try {
+                    sessionStorage.setItem('auth_user_cache', JSON.stringify(Object.assign(Object.assign({}, user), { cached_at: Date.now(), cache_version: CACHE_VERSION })));
+                }
+                catch (error) {
+                    // Storage error - continue without caching (graceful degradation)
+                    logStorageError('write', error);
+                }
+            }
+        }
+        catch (error) {
+            // User not authenticated, that's fine
+            setUser(null);
+            if (typeof window !== 'undefined') {
+                try {
+                    sessionStorage.removeItem('auth_user_cache');
+                }
+                catch (error) {
+                    // Storage error - continue with graceful degradation
+                    logStorageError('remove', error);
+                }
+            }
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [authClient]);
+    const logout = useCallback(async (reason) => {
+        try {
+            await authClient.logout();
+        }
+        catch (error) {
+            // Logout error - continue with local logout regardless
+            debugLog('Backend logout failed, continuing with local cleanup', error);
+            // Could show a non-blocking notification here if needed
+        }
+        finally {
+            // Clear the httpOnly graph/entity selection cookies server-side. These
+            // can't be removed by performLogoutCleanup() (which only touches
+            // JS-readable cookies), so the server actions are still required. Bound
+            // them with a timeout while the page is still authenticated: once the
+            // auth token is cleared, these server actions can stall, and awaiting
+            // them unconditionally previously hung logout() forever — leaving
+            // AuthGuard on a blank screen with no redirect.
+            await Promise.race([
+                Promise.allSettled([clearGraphSelection(), clearEntitySelection()]),
+                new Promise((resolve) => setTimeout(resolve, 2000)),
+            ]);
+            // Clear auth client cache and local user/session state
+            authClient.clearAuthCache();
+            setUser(null);
+            setSessionWarning({ show: false, timeLeft: 0 });
+            // Perform comprehensive cleanup of all user-specific data
+            performLogoutCleanup();
+            debugLog('Logout cleanup completed');
+            // Always hard-redirect out of the authenticated area. A full-page
+            // navigation (not a client-side router.push) guarantees the
+            // authenticated tree tears down instead of AuthGuard flashing a blank
+            // screen once user state clears. A forced logout (reason set, e.g.
+            // session_expired) goes to the login page so it can explain why the
+            // session ended and let the user sign back in; a manual logout goes to
+            // the public homepage, since the user likely isn't trying to sign in
+            // again right away.
+            if (typeof window !== 'undefined') {
+                window.location.href = reason ? `/login?reason=${reason}` : '/';
+            }
+        }
+    }, [authClient]);
+    const refreshUser = useCallback(async () => {
+        try {
+            authClient.clearAuthCache();
+            const freshUser = await authClient.getCurrentUser();
+            setUser(freshUser);
+            if (typeof window !== 'undefined') {
+                try {
+                    sessionStorage.setItem('auth_user_cache', JSON.stringify(Object.assign(Object.assign({}, freshUser), { cached_at: Date.now(), cache_version: CACHE_VERSION })));
+                }
+                catch (error) {
+                    logStorageError('write', error);
+                }
+            }
+            return freshUser;
+        }
+        catch (error) {
+            debugLog('Failed to refresh user', error);
+            return null;
+        }
+    }, [authClient]);
+    const refreshSession = useCallback(async (force = false) => {
+        const now = Date.now();
+        if (refreshInProgress.current) {
+            debugLog('Refresh already in progress, skipping duplicate attempt');
+            return;
+        }
+        if (!force && now - lastRefreshAttempt.current < REFRESH_COOLDOWN_MS) {
+            debugLog(`Skipping refresh - too soon since last attempt (< ${REFRESH_COOLDOWN_MS / 1000}s)`);
+            return;
+        }
+        refreshInProgress.current = true;
+        lastRefreshAttempt.current = now;
+        debugLog(force
+            ? 'Starting user-initiated session refresh'
+            : 'Starting session refresh');
+        try {
+            const response = await authClient.refreshSession();
+            if (response.success) {
+                setUser(response.user);
+                // Cache the refreshed user data
+                if (typeof window !== 'undefined') {
+                    try {
+                        sessionStorage.setItem('auth_user_cache', JSON.stringify(Object.assign(Object.assign({}, response.user), { cached_at: Date.now(), cache_version: CACHE_VERSION })));
+                    }
+                    catch (error) {
+                        logStorageError('write', error);
+                    }
+                }
+                debugLog('Session refresh successful');
+            }
+            else {
+                throw new Error('Session refresh failed');
+            }
+        }
+        finally {
+            refreshInProgress.current = false;
+        }
+    }, [authClient]);
+    // Set up global 401 error handler
+    useTokenExpiryHandler(logout);
+    // Check session on mount with caching
+    useEffect(() => {
+        if (typeof window === 'undefined') {
+            return; // Skip during SSR
+        }
+        let cachedUser = null;
+        try {
+            cachedUser = sessionStorage.getItem('auth_user_cache');
+        }
+        catch (error) {
+            // Storage access error - proceed without cache
+        }
+        if (cachedUser) {
+            try {
+                const userData = JSON.parse(cachedUser);
+                // Validate cache structure and version
+                if (!userData || typeof userData !== 'object' || !userData.id) {
+                    throw new Error('Invalid cache structure');
+                }
+                // Check cache version - invalidate if version mismatch
+                if (userData.cache_version !== CACHE_VERSION) {
+                    debugLog('Cache version mismatch, invalidating cache');
+                    throw new Error('Cache version mismatch');
+                }
+                const cacheAge = Date.now() - (userData.cached_at || 0);
+                // If cache is fresh (< 5 minutes), use cached data
+                if (cacheAge < CACHE_TTL_MS) {
+                    setUser(userData);
+                    setIsLoading(false);
+                    // Validate in background without blocking UI
+                    validateCachedUser(userData);
+                    return;
+                }
+            }
+            catch (error) {
+                // Invalid cache, proceed with normal check
+                try {
+                    sessionStorage.removeItem('auth_user_cache');
+                }
+                catch (removeError) {
+                    // Storage error - continue silently
+                    debugLog('sessionStorage remove failed during cache invalidation', removeError);
+                }
+            }
+        }
+        checkSession();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // Heartbeat - Server-side validation and background tab refresh
+    useEffect(() => {
+        if (!isAuthenticated)
+            return;
+        let isMounted = true;
+        const performHeartbeat = async () => {
+            if (!isMounted)
+                return;
+            debugLog('Heartbeat: Checking server authentication status');
+            try {
+                // Make real HTTP call to validate session server-side
+                // This works even in background tabs (not throttled like timers)
+                await authClient.getCurrentUser();
+                if (!isMounted)
+                    return;
+                debugLog('Heartbeat: Server validation successful');
+                // After successful server check, verify local token status
+                const tokenStatus = getTokenStatus();
+                const timeLeft = getTimeUntilExpiry();
+                // Proactively refresh if token is expiring soon
+                if (tokenStatus === 'warning' ||
+                    tokenStatus === 'expired' ||
+                    timeLeft < 5 * 60 * 1000) {
+                    debugLog(`Heartbeat: Token needs refresh (status: ${tokenStatus}, time left: ${Math.floor(timeLeft / 1000)}s)`);
+                    try {
+                        await refreshSession();
+                        if (!isMounted)
+                            return;
+                        debugLog('Heartbeat: Token refresh successful');
+                        setSessionWarning({ show: false, timeLeft: 0 });
+                    }
+                    catch (refreshError) {
+                        if (!isMounted)
+                            return;
+                        debugLog('Heartbeat: Token refresh failed', refreshError);
+                        // Show warning if refresh failed but token not expired
+                        if (timeLeft > 0) {
+                            setSessionWarning({
+                                show: true,
+                                timeLeft: Math.ceil(timeLeft / 1000),
+                            });
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                if (!isMounted)
+                    return;
+                debugLog('Heartbeat: Server validation failed - user may be logged out', error);
+                // Server says we're not authenticated - immediate logout
+                await logout('session_invalid');
+            }
+        };
+        // Regular heartbeat interval
+        const heartbeatInterval = setInterval(performHeartbeat, HEARTBEAT_INTERVAL_MS); // Every 5 minutes
+        // Also check immediately when tab regains focus
+        const handleFocus = () => {
+            if (!isMounted)
+                return;
+            debugLog('Tab regained focus - performing immediate heartbeat');
+            performHeartbeat();
+        };
+        const handleVisibilityChange = () => {
+            if (!isMounted)
+                return;
+            if (!document.hidden) {
+                debugLog('Tab became visible - performing immediate heartbeat');
+                performHeartbeat();
+            }
+        };
+        window.addEventListener('focus', handleFocus);
+        document.addEventListener('visibilitychange', handleVisibilityChange);
+        return () => {
+            isMounted = false;
+            clearInterval(heartbeatInterval);
+            window.removeEventListener('focus', handleFocus);
+            document.removeEventListener('visibilitychange', handleVisibilityChange);
+        };
+    }, [isAuthenticated, authClient, refreshSession, logout]);
+    // Proactive token refresh BEFORE expiry (kept for immediate refresh needs)
+    useEffect(() => {
+        if (!isAuthenticated)
+            return;
+        let isMounted = true;
+        const refreshInterval = setInterval(async () => {
+            if (!isMounted)
+                return;
+            const tokenStatus = getTokenStatus();
+            // If token is in warning state or expired, refresh it
+            if (tokenStatus === 'warning' || tokenStatus === 'expired') {
+                debugLog(`Token status: ${tokenStatus}, attempting refresh`);
+                try {
+                    await refreshSession();
+                    if (!isMounted)
+                        return;
+                    setSessionWarning({ show: false, timeLeft: 0 });
+                }
+                catch (error) {
+                    if (!isMounted)
+                        return;
+                    debugLog('Token refresh failed', error);
+                    // Show warning instead of silent logout
+                    const timeLeft = getTimeUntilExpiry();
+                    if (timeLeft > 0) {
+                        setSessionWarning({
+                            show: true,
+                            timeLeft: Math.ceil(timeLeft / 1000),
+                        });
+                    }
+                    else {
+                        // Token is actually expired, need to re-authenticate
+                        debugLog('Token expired, redirecting to login');
+                        await logout('session_expired');
+                    }
+                }
+            }
+        }, TOKEN_REFRESH_INTERVAL_MS); // Check every 25 minutes
+        // Also check token status more frequently and auto-refresh if needed
+        const warningInterval = setInterval(async () => {
+            if (!isMounted)
+                return;
+            const tokenStatus = getTokenStatus();
+            const timeLeft = getTimeUntilExpiry();
+            if (tokenStatus === 'warning' && timeLeft > 0) {
+                // Token is approaching expiry - try to auto-refresh before showing warning
+                debugLog('Token in warning state, attempting auto-refresh');
+                try {
+                    await refreshSession();
+                    if (!isMounted)
+                        return;
+                    debugLog('Auto-refresh successful, warning modal suppressed');
+                    setSessionWarning({ show: false, timeLeft: 0 });
+                }
+                catch (error) {
+                    if (!isMounted)
+                        return;
+                    // Auto-refresh failed, show warning modal
+                    debugLog('Auto-refresh failed, showing warning modal', error);
+                    setSessionWarning({
+                        show: true,
+                        timeLeft: Math.ceil(timeLeft / 1000),
+                    });
+                }
+            }
+            else if (tokenStatus === 'valid') {
+                if (!isMounted)
+                    return;
+                setSessionWarning({ show: false, timeLeft: 0 });
+            }
+        }, TOKEN_WARNING_CHECK_INTERVAL_MS); // Check every 10 seconds
+        return () => {
+            isMounted = false;
+            clearInterval(refreshInterval);
+            clearInterval(warningInterval);
+        };
+    }, [isAuthenticated, refreshSession, logout]);
+    // Track user activity with throttling
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const updateActivity = () => {
+            // Clear existing timeout to prevent race conditions
+            if (activityTimeoutRef.current) {
+                clearTimeout(activityTimeoutRef.current);
+            }
+            activityTimeoutRef.current = setTimeout(() => {
+                // Check if component is still mounted before updating
+                if (mounted.current) {
+                    lastActivity.current = Date.now();
+                }
+                activityTimeoutRef.current = null;
+            }, ACTIVITY_THROTTLE_MS); // Update at most once per second
+        };
+        const options = { passive: true };
+        window.addEventListener('mousedown', updateActivity, options);
+        window.addEventListener('keydown', updateActivity, options);
+        window.addEventListener('scroll', updateActivity, options);
+        window.addEventListener('touchstart', updateActivity, options);
+        return () => {
+            if (activityTimeoutRef.current) {
+                clearTimeout(activityTimeoutRef.current);
+            }
+            window.removeEventListener('mousedown', updateActivity);
+            window.removeEventListener('keydown', updateActivity);
+            window.removeEventListener('scroll', updateActivity);
+            window.removeEventListener('touchstart', updateActivity);
+        };
+    }, []);
+    // Track component mount status
+    useEffect(() => {
+        mounted.current = true;
+        return () => {
+            mounted.current = false;
+        };
+    }, []);
+    const login = async (email, password) => {
+        const response = await authClient.login(email, password);
+        if (response.success) {
+            authClient.clearAuthCache(); // Clear request deduplication cache
+            setUser(response.user);
+            // Cache the user data
+            if (typeof window !== 'undefined') {
+                try {
+                    sessionStorage.setItem('auth_user_cache', JSON.stringify(Object.assign(Object.assign({}, response.user), { cached_at: Date.now(), cache_version: CACHE_VERSION })));
+                }
+                catch (error) {
+                    // Storage error - continue without caching (graceful degradation)
+                    logStorageError('write', error);
+                }
+            }
+            return response.user;
+        }
+        else {
+            throw new Error(response.message || 'Login failed');
+        }
+    };
+    const register = async (email, password, name) => {
+        const response = await authClient.register(email, password, name);
+        if (response.success) {
+            authClient.clearAuthCache(); // Clear request deduplication cache
+            setUser(response.user);
+            // Cache the user data
+            if (typeof window !== 'undefined') {
+                try {
+                    sessionStorage.setItem('auth_user_cache', JSON.stringify(Object.assign(Object.assign({}, response.user), { cached_at: Date.now(), cache_version: CACHE_VERSION })));
+                }
+                catch (error) {
+                    // Storage error - continue without caching (graceful degradation)
+                    logStorageError('write', error);
+                }
+            }
+            return response.user;
+        }
+        else {
+            throw new Error(response.message || 'Registration failed');
+        }
+    };
+    const forgotPassword = async (email) => {
+        return authClient.forgotPassword(email);
+    };
+    const resetPassword = async (token, newPassword) => {
+        const result = await authClient.resetPassword(token, newPassword);
+        // If reset was successful and logged in automatically, fetch user
+        if (result.success) {
+            try {
+                const user = await authClient.getCurrentUser();
+                if (user) {
+                    setUser(user);
+                }
+            }
+            catch (_a) {
+                // User not logged in after reset, that's fine
+            }
+        }
+        return result;
+    };
+    const validateResetToken = async (token) => {
+        return authClient.validateResetToken(token);
+    };
+    const verifyEmail = async (token) => {
+        const result = await authClient.verifyEmail(token);
+        // If verification was successful and logged in automatically, update user
+        if (result.success && result.user) {
+            setUser(result.user);
+            // Cache the user data
+            if (typeof window !== 'undefined') {
+                try {
+                    sessionStorage.setItem('auth_user_cache', JSON.stringify(Object.assign(Object.assign({}, result.user), { cached_at: Date.now(), cache_version: CACHE_VERSION })));
+                }
+                catch (error) {
+                    // Storage error - continue without caching (graceful degradation)
+                    logStorageError('write', error);
+                }
+            }
+        }
+        return result;
+    };
+    const resendVerificationEmail = async (email) => {
+        return authClient.resendVerificationEmail(email);
+    };
+    const value = {
+        user,
+        isLoading,
+        isAuthenticated,
+        sessionWarning,
+        login,
+        register,
+        logout,
+        refreshUser,
+        refreshSession,
+        forgotPassword,
+        resetPassword,
+        validateResetToken,
+        verifyEmail,
+        resendVerificationEmail,
+    };
+    return _jsx(AuthContext.Provider, { value: value, children: children });
+}
+export function useAuth() {
+    const context = useContext(AuthContext);
+    if (!context) {
+        throw new Error('useAuth must be used within an AuthProvider');
+    }
+    return context;
+}

package/auth-components/SessionWarningDialog.d.ts

@@ -0,0 +1 @@
+export declare function SessionWarningDialog(): import("react").JSX.Element;

package/auth-components/SessionWarningDialog.js

@@ -0,0 +1,51 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useState } from 'react';
+import { useAuth } from './AuthProvider';
+export function SessionWarningDialog() {
+    const { sessionWarning, refreshSession, logout } = useAuth();
+    const [countdown, setCountdown] = useState(0);
+    const [isRefreshing, setIsRefreshing] = useState(false);
+    useEffect(() => {
+        if (sessionWarning.show && sessionWarning.timeLeft > 0) {
+            setCountdown(sessionWarning.timeLeft);
+        }
+    }, [sessionWarning]);
+    useEffect(() => {
+        if (!sessionWarning.show || countdown <= 0)
+            return;
+        const timer = setInterval(() => {
+            setCountdown((prev) => {
+                if (prev <= 1) {
+                    // Time's up, logout
+                    logout();
+                    return 0;
+                }
+                return prev - 1;
+            });
+        }, 1000);
+        return () => clearInterval(timer);
+    }, [sessionWarning.show, countdown, logout]);
+    const handleRefresh = useCallback(async () => {
+        setIsRefreshing(true);
+        try {
+            await refreshSession(true); // Force refresh to bypass cooldown
+            // Success - dialog will be hidden by AuthProvider
+        }
+        catch (error) {
+            console.error('Failed to refresh session:', error);
+            // Error handling - user will see the error
+        }
+        finally {
+            setIsRefreshing(false);
+        }
+    }, [refreshSession]);
+    const handleLogout = useCallback(async () => {
+        await logout();
+    }, [logout]);
+    if (!sessionWarning.show)
+        return null;
+    const minutes = Math.floor(countdown / 60);
+    const seconds = countdown % 60;
+    return (_jsx("div", { className: "bg-opacity-50 fixed inset-0 z-50 flex items-center justify-center bg-black", children: _jsxs("div", { className: "mx-4 max-w-md rounded-lg bg-white p-6 shadow-xl dark:bg-gray-800", children: [_jsx("h2", { className: "mb-4 text-xl font-semibold text-gray-900 dark:text-white", children: "Session Expiring Soon" }), _jsxs("p", { className: "mb-6 text-gray-600 dark:text-gray-300", children: ["Your session will expire in", ' ', _jsx("span", { className: "font-semibold text-red-600 dark:text-red-400", children: minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s` }), ". Would you like to stay logged in?"] }), _jsxs("div", { className: "flex gap-3", children: [_jsx("button", { onClick: handleRefresh, disabled: isRefreshing, className: "bg-primary-700 hover:bg-primary-800 focus:ring-primary-300 dark:bg-primary-600 dark:hover:bg-primary-700 dark:focus:ring-primary-800 flex-1 rounded-lg px-4 py-2 text-white focus:ring-4 focus:outline-none disabled:opacity-50", children: isRefreshing ? 'Refreshing...' : 'Stay Logged In' }), _jsx("button", { onClick: handleLogout, className: "flex-1 rounded-lg border border-gray-300 bg-white px-4 py-2 text-gray-700 hover:bg-gray-100 focus:ring-4 focus:ring-gray-200 focus:outline-none dark:border-gray-600 dark:bg-gray-700 dark:text-white dark:hover:bg-gray-600 dark:focus:ring-gray-700", children: "Logout" })] })] }) }));
+}

package/auth-components/SignInForm.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { AuthUser } from '../auth-core/types';
+export interface SignInFormProps {
+    onSuccess?: (user: AuthUser) => void;
+    onRedirect?: (url: string) => void;
+    redirectTo?: string;
+    className?: string;
+    apiUrl: string;
+    enableSSO?: boolean;
+    currentApp?: string;
+}
+/**
+ * Map a login failure to a user-facing message. A connectivity failure (the
+ * request never reached the server — `fetch` throws a `TypeError`) must NOT be
+ * reported as bad credentials: that sends users to reset a password that is
+ * actually correct. Reached-server auth rejection (401/403, or an empty/invalid
+ * auth body) stays "Invalid email or password"; 5xx gets its own message.
+ */
+export declare function loginErrorMessage(error: unknown): string;
+export declare function SignInForm({ onSuccess, onRedirect, redirectTo, className, apiUrl, enableSSO, currentApp, }: SignInFormProps): React.JSX.Element;