Frontend completo (Etapas 11-18) e extensões de backend (Etapas 13 e 18)

Adiciona o frontend Next.js em frontend/ (setup, design system,
autenticação/tema, layout/navegação, área master, área tenant completa:
clientes, produtos, vendas, recebimentos, whatsapp, e-mail, alertas,
equipe e perfil). Estende o backend de forma aditiva e autorizada:
cookie httpOnly para refresh token (Etapa 13) e CRUD de equipe +
edição de perfil do tenant (Etapa 18, módulo src/modules/equipe/ novo
e PUT /tenant/perfil). Detalhes completos em Etapas/V2/*.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

frontend/lib/auth/auth-context.tsx

@@ -0,0 +1,130 @@
+'use client';
+
+import * as React from 'react';
+import { apiClient, authInterceptor, fetchRefreshToken } from '@/lib/api/client';
+import { clearSessionCookie, setSessionCookie } from '@/lib/auth/session-cookie';
+import { decodeJwt, type JwtPayload } from '@/lib/auth/jwt';
+
+interface LoginResponse {
+  access_token: string;
+}
+
+type AuthStatus = 'loading' | 'authenticated' | 'unauthenticated';
+
+interface AuthContextValue {
+  status: AuthStatus;
+  user: JwtPayload | null;
+  loginMaster: (email: string, senha: string) => Promise<void>;
+  loginTenant: (email: string, senha: string) => Promise<void>;
+  logout: () => Promise<void>;
+}
+
+const AuthContext = React.createContext<AuthContextValue | null>(null);
+
+/**
+ * Fonte única de sessão do app (Etapa 13). Access token só existe em
+ * memória (`tokenRef`/estado do React) — nunca em `localStorage`. O
+ * refresh token real vive só no cookie httpOnly do backend; este
+ * Provider nunca o lê nem o guarda, só dispara `POST /auth/refresh` (que
+ * o browser já anexa o cookie automaticamente) e reage ao resultado.
+ */
+export function AuthProvider({ children }: { children: React.ReactNode }) {
+  const tokenRef = React.useRef<string | null>(null);
+  const [status, setStatus] = React.useState<AuthStatus>('loading');
+  const [user, setUser] = React.useState<JwtPayload | null>(null);
+  // Deduplica chamadas concorrentes a `refreshSession` (ver comentário abaixo).
+  const refreshPromiseRef = React.useRef<Promise<boolean> | null>(null);
+
+  const applyToken = React.useCallback((token: string | null) => {
+    tokenRef.current = token;
+    setUser(token ? decodeJwt(token) : null);
+    setStatus(token ? 'authenticated' : 'unauthenticated');
+  }, []);
+
+  /**
+   * Duas fontes independentes podem chamar isto quase ao mesmo tempo logo
+   * após um reload de página protegida: o efeito de montagem deste
+   * Provider (recupera a sessão) e `authInterceptor.onUnauthorized`
+   * (disparado por um 401 de uma request que saiu antes do token estar
+   * pronto). Sem deduplicar, a 2ª chamada reenvia o mesmo cookie de
+   * refresh que a 1ª já rotacionou — o backend trata isso como reuso de
+   * token revogado e revoga a família inteira (Etapa 2), derrubando a
+   * sessão que a 1ª chamada acabou de validar. Compartilhar a mesma
+   * promise entre chamadas concorrentes evita a corrida.
+   */
+  const refreshSession = React.useCallback((): Promise<boolean> => {
+    if (refreshPromiseRef.current) return refreshPromiseRef.current;
+
+    const promise = (async () => {
+      try {
+        const result = await fetchRefreshToken();
+        if (!result) {
+          applyToken(null);
+          clearSessionCookie();
+          return false;
+        }
+        applyToken(result.access_token);
+        return true;
+      } finally {
+        refreshPromiseRef.current = null;
+      }
+    })();
+
+    refreshPromiseRef.current = promise;
+    return promise;
+  }, [applyToken]);
+
+  // Gancho deixado pronto na Etapa 11: liga o client HTTP à sessão atual.
+  React.useEffect(() => {
+    authInterceptor.getAccessToken = () => tokenRef.current;
+    authInterceptor.onUnauthorized = refreshSession;
+  }, [refreshSession]);
+
+  // Recupera a sessão em memória após um reload de página (o access token
+  // não sobrevive a isso de propósito — só o cookie httpOnly sobrevive).
+  React.useEffect(() => {
+    void refreshSession();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  const loginMaster = React.useCallback(
+    async (email: string, senha: string) => {
+      const tokens = await apiClient.post<LoginResponse>('/auth/master/login', { email, senha });
+      applyToken(tokens.access_token);
+      setSessionCookie('master');
+    },
+    [applyToken],
+  );
+
+  const loginTenant = React.useCallback(
+    async (email: string, senha: string) => {
+      const tokens = await apiClient.post<LoginResponse>('/auth/tenant/login', { email, senha });
+      applyToken(tokens.access_token);
+      setSessionCookie('tenant');
+    },
+    [applyToken],
+  );
+
+  const logout = React.useCallback(async () => {
+    try {
+      await apiClient.post('/auth/logout', {});
+    } catch {
+      // mesmo se a chamada falhar (ex: rede), a sessão local é limpa de qualquer forma
+    }
+    applyToken(null);
+    clearSessionCookie();
+  }, [applyToken]);
+
+  const value = React.useMemo(
+    () => ({ status, user, loginMaster, loginTenant, logout }),
+    [status, user, loginMaster, loginTenant, logout],
+  );
+
+  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
+}
+
+export function useAuth(): AuthContextValue {
+  const ctx = React.useContext(AuthContext);
+  if (!ctx) throw new Error('useAuth precisa estar dentro de <AuthProvider>');
+  return ctx;
+}