Sessoes 1-6 acumuladas: hardening B2, defesa em camadas, +192 testes

Repositorio estava ha ~5 sessoes sem commit. Consolida tudo desde d088a89.

Ver commit.md na raiz para descricao completa por sessao.

# Numeros
- A# auditoria abertos: 0/30
- V# verificacoes abertos: 5/52 (todos adiados com plano)
- T# testes escritos: 10/10
- Vitest: 192/192
- SQL integration: 33/33
- E2E (Playwright, novo): 5/5
- Migrations: 17 (10 novas Sessao 6)
- Areas auditadas: 7 (+documentos com 10 V#)

# Highlights Sessao 6 (hoje)
- V#34/V#41 Opcao B2: tenant_features com plano + override (RPC SECURITY DEFINER, tela /saas/tenant-features)
- A#20 rev2 self-hosted: defesa em 5 camadas (honeypot + rate limit + math captcha condicional + paranoid mode + dashboard /saas/security)
- Documentos hardening (V#43-V#49): tenant scoping em storage policies (vazamento entre clinicas eliminado), RPC validate_share_token, signatures policy granular
- SaaS Twilio Config (/saas/twilio-config): UI editavel para SID/webhook/cotacao; AUTH_TOKEN permanece em env var
- T#9 + T#10: useAgendaEvents.spec.js + Playwright E2E (descobriu bug no front que foi corrigido)

# Sessoes anteriores (1-5) consolidadas
- Sessao 1: auth/router/session, normalizeRole extraido
- Sessao 2: agenda - composables/services consolidados
- Sessao 3: pacientes - tenant_id em todas queries
- Sessao 4: security review pagina publica - 14/15 vulnerabilidades corrigidas
- Sessao 5: SaaS - P0 (A#30: 7 tabelas com RLS off corrigidas)

# .gitignore ajustado
- supabase/* + !supabase/functions/ (mantem 10 edge functions, ignora .temp/migrations gerados pelo CLI)
- database-novo/backups/ (regeneravel via db.cjs backup)
- test-results/ + playwright-report/
- .claude/settings.local.json (config local com senha de dev removida do tracking)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

src/app/__tests__/session.spec.js

@@ -0,0 +1,219 @@
+/**
+ * session.spec.js
+ *
+ * Cobre o módulo de sessão global — foco nas race conditions documentadas
+ * no próprio session.js (singleflight, SIGNED_IN redundante, TOKEN_REFRESHED).
+ *
+ * Mock do supabase: capturamos o callback de onAuthStateChange pra disparar
+ * eventos manualmente e observar o state dos refs reativos.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Captura do callback de onAuthStateChange (setado no listenAuthChanges)
+let authCallback = null;
+
+// Mock configurável de getSession (pode trocar em cada teste via mockImplementation)
+const getSessionMock = vi.fn();
+const profileSingleMock = vi.fn();
+const saasMaybeSingleMock = vi.fn();
+
+vi.mock('@/lib/supabase/client', () => {
+    const from = vi.fn((table) => {
+        return {
+            select: vi.fn().mockReturnThis(),
+            eq: vi.fn().mockReturnThis(),
+            maybeSingle: table === 'saas_admins' ? saasMaybeSingleMock : profileSingleMock,
+            single: vi.fn().mockResolvedValue({ data: null, error: null })
+        };
+    });
+
+    return {
+        supabase: {
+            auth: {
+                getSession: getSessionMock,
+                onAuthStateChange: vi.fn((cb) => {
+                    authCallback = cb;
+                    return { data: { subscription: { unsubscribe: vi.fn() } } };
+                })
+            },
+            from
+        }
+    };
+});
+
+vi.mock('@/support/supportLogger', () => ({
+    logAuth: vi.fn(),
+    logError: vi.fn()
+}));
+
+// Importa depois dos mocks
+const session = await import('../session.js');
+
+beforeEach(() => {
+    // Reseta state dos refs e mocks a cada teste
+    session.sessionUser.value = null;
+    session.sessionRole.value = null;
+    session.sessionIsSaasAdmin.value = false;
+    session.sessionReady.value = false;
+    session.sessionRefreshing.value = false;
+
+    // Desfaz listenAuthChanges de teste anterior pra permitir re-registro
+    session.stopAuthChanges();
+
+    authCallback = null;
+    getSessionMock.mockReset();
+    profileSingleMock.mockReset();
+    saasMaybeSingleMock.mockReset();
+
+    // defaults razoáveis
+    profileSingleMock.mockResolvedValue({ data: { role: 'therapist' }, error: null });
+    saasMaybeSingleMock.mockResolvedValue({ data: null, error: null });
+});
+
+describe('initSession — boot inicial', () => {
+    it('sem sessão → zera user/role/saasAdmin', async () => {
+        getSessionMock.mockResolvedValue({ data: { session: null }, error: null });
+
+        await session.initSession({ initial: true });
+
+        expect(session.sessionUser.value).toBe(null);
+        expect(session.sessionRole.value).toBe(null);
+        expect(session.sessionIsSaasAdmin.value).toBe(false);
+        expect(session.sessionReady.value).toBe(true);
+        expect(session.sessionRefreshing.value).toBe(false);
+    });
+
+    it('com sessão → hydrata user + busca role', async () => {
+        getSessionMock.mockResolvedValue({
+            data: { session: { user: { id: 'uid-1' } } },
+            error: null
+        });
+        profileSingleMock.mockResolvedValue({ data: { role: 'clinic_admin' }, error: null });
+
+        await session.initSession({ initial: true });
+
+        expect(session.sessionUser.value?.id).toBe('uid-1');
+        expect(session.sessionRole.value).toBe('clinic_admin');
+        expect(session.sessionReady.value).toBe(true);
+    });
+
+    it('erro em getSession → state zerado (não propaga)', async () => {
+        getSessionMock.mockRejectedValue(new Error('network down'));
+
+        await session.initSession({ initial: true });
+
+        expect(session.sessionUser.value).toBe(null);
+        expect(session.sessionRole.value).toBe(null);
+        expect(session.sessionReady.value).toBe(true); // ainda marca ready pra não travar o guard
+    });
+
+    it('singleflight: 2 chamadas concorrentes fazem apenas 1 getSession', async () => {
+        let resolveGet;
+        getSessionMock.mockImplementation(() => new Promise((resolve) => { resolveGet = resolve; }));
+
+        const p1 = session.initSession({ initial: true });
+        const p2 = session.initSession({ initial: true });
+
+        // segunda chamada deve ter retornado a mesma promise (sem disparar getSession de novo)
+        expect(getSessionMock).toHaveBeenCalledTimes(1);
+
+        resolveGet({ data: { session: null }, error: null });
+        await Promise.all([p1, p2]);
+    });
+});
+
+describe('refreshSession — evita corrida', () => {
+    it('não dispara se já está refreshing', async () => {
+        session.sessionRefreshing.value = true;
+
+        await session.refreshSession();
+
+        expect(getSessionMock).not.toHaveBeenCalled();
+    });
+
+    it('sem sessão → não zera state existente (SIGNED_OUT cuida)', async () => {
+        session.sessionUser.value = { id: 'uid-1' };
+        session.sessionRole.value = 'therapist';
+        getSessionMock.mockResolvedValue({ data: { session: null }, error: null });
+
+        await session.refreshSession();
+
+        // State preservado — refreshSession não é quem zera (é SIGNED_OUT)
+        expect(session.sessionUser.value?.id).toBe('uid-1');
+        expect(session.sessionRole.value).toBe('therapist');
+    });
+
+    it('mesma sessão consistente → no-op', async () => {
+        session.sessionUser.value = { id: 'uid-1' };
+        session.sessionRole.value = 'therapist';
+        getSessionMock.mockResolvedValue({
+            data: { session: { user: { id: 'uid-1' } } },
+            error: null
+        });
+
+        await session.refreshSession();
+
+        // initSession não foi chamado de novo (state já era consistente)
+        expect(getSessionMock).toHaveBeenCalledTimes(1); // só o refreshSession próprio
+    });
+});
+
+describe('listenAuthChanges — callbacks de auth', () => {
+    it('SIGNED_OUT zera state + chama callback', async () => {
+        const onOut = vi.fn();
+        session.setOnSignedOut(onOut);
+        session.listenAuthChanges();
+
+        // simula state previamente hydratado
+        session.sessionUser.value = { id: 'uid-1' };
+        session.sessionRole.value = 'therapist';
+        session.sessionIsSaasAdmin.value = true;
+        session.sessionRefreshing.value = true;
+
+        expect(authCallback).toBeTypeOf('function');
+        await authCallback('SIGNED_OUT', null);
+
+        expect(session.sessionUser.value).toBe(null);
+        expect(session.sessionRole.value).toBe(null);
+        expect(session.sessionIsSaasAdmin.value).toBe(false);
+        expect(session.sessionRefreshing.value).toBe(false);
+        expect(session.sessionReady.value).toBe(true);
+        expect(onOut).toHaveBeenCalledTimes(1);
+    });
+
+    it('SIGNED_IN com mesmo user (redundante) é ignorado', async () => {
+        session.listenAuthChanges();
+        session.sessionUser.value = { id: 'uid-1' };
+        session.sessionRole.value = 'therapist';
+        session.sessionReady.value = true;
+
+        await authCallback('SIGNED_IN', { user: { id: 'uid-1' } });
+
+        // Não rehidratou — profileSingleMock não foi chamado
+        expect(profileSingleMock).not.toHaveBeenCalled();
+    });
+
+    it('SIGNED_IN com user diferente → hydrata novo', async () => {
+        session.listenAuthChanges();
+        session.sessionUser.value = { id: 'uid-1' };
+        session.sessionRole.value = 'therapist';
+        session.sessionReady.value = true;
+
+        profileSingleMock.mockResolvedValue({ data: { role: 'clinic_admin' }, error: null });
+
+        await authCallback('SIGNED_IN', { user: { id: 'uid-2' } });
+
+        expect(session.sessionUser.value?.id).toBe('uid-2');
+        expect(session.sessionRole.value).toBe('clinic_admin');
+    });
+});
+
+describe('stopAuthChanges — cleanup', () => {
+    it('unsubscribe é chamado', () => {
+        session.listenAuthChanges();
+        session.stopAuthChanges();
+
+        // não deve lançar erro se chamar de novo
+        expect(() => session.stopAuthChanges()).not.toThrow();
+    });
+});

src/app/session.js

@@ -16,6 +16,7 @@
 */
 import { ref } from 'vue';
 import { supabase } from '@/lib/supabase/client';
+import { logAuth, logError } from '@/support/supportLogger';
 
 /**
  * ⚠️ IMPORTANTE — ESTABILIDADE DE NAVEGAÇÃO
@@ -57,11 +58,44 @@ export function setOnSignedOut(cb) {
     onSignedOutCallback = typeof cb === 'function' ? cb : null;
 }
 
+// V#2: session.js é o único registrante de supabase.auth.onAuthStateChange.
+// Outros módulos (guards.js, etc.) se inscrevem aqui via onSessionEvent
+// em vez de registrar listeners próprios.
+const eventHandlers = {
+    SIGNED_IN: [],
+    SIGNED_OUT: [],
+    TOKEN_REFRESHED: [],
+    USER_UPDATED: []
+};
+
+/**
+ * Inscreve handler para um evento de auth processado por listenAuthChanges.
+ * Retorna função pra desregistrar.
+ *
+ * @param {'SIGNED_IN'|'SIGNED_OUT'|'TOKEN_REFRESHED'|'USER_UPDATED'} event
+ * @param {(session: object|null) => void} handler
+ */
+export function onSessionEvent(event, handler) {
+    if (!eventHandlers[event] || typeof handler !== 'function') return () => {};
+    eventHandlers[event].push(handler);
+    return () => {
+        eventHandlers[event] = eventHandlers[event].filter((h) => h !== handler);
+    };
+}
+
+function dispatch(event, sess) {
+    const handlers = eventHandlers[event];
+    if (!handlers || !handlers.length) return;
+    for (const h of handlers) {
+        try { h(sess); } catch (e) { logError('session', `${event} handler failed`, e); }
+    }
+}
+
 // evita init concorrente
 let initPromise = null;
 
 async function fetchRole(userId) {
-    const { data, error } = await supabase.from('profiles').select('role').eq('id', userId).single();
+    const { data, error } = await supabase.from('profiles').select('role').eq('id', userId).maybeSingle();
 
     if (error) return null;
     return data?.role || null;
@@ -129,7 +163,7 @@ export async function initSession({ initial = false } = {}) {
                 sessionIsSaasAdmin.value = false;
             }
         } catch (e) {
-            console.warn('[initSession] getSession falhou (tratando como sem sessão):', e);
+            logError('session', 'initSession.getSession falhou (tratando como sem sessão)', e);
             // não deixa estourar pro router guard
             sessionUser.value = null;
             sessionRole.value = null;
@@ -173,7 +207,7 @@ export function listenAuthChanges() {
     if (authSubscription) return;
 
     const { data } = supabase.auth.onAuthStateChange(async (event, sess) => {
-        console.log('[AUTH EVENT]', event);
+        logAuth('event', { event });
 
         // ✅ SIGNED_OUT: zera e chama callback
         if (event === 'SIGNED_OUT') {
@@ -183,6 +217,7 @@ export function listenAuthChanges() {
             sessionRefreshing.value = false;
             sessionReady.value = true;
             if (onSignedOutCallback) onSignedOutCallback();
+            dispatch('SIGNED_OUT', sess);
             return;
         }
 
@@ -190,6 +225,7 @@ export function listenAuthChanges() {
         if (event === 'SIGNED_IN') {
             const uid = sess?.user?.id || null;
             if (uid && sessionReady.value && sessionUser.value?.id === uid && sessionRole.value) {
+                dispatch('SIGNED_IN', sess);
                 return;
             }
         }
@@ -204,10 +240,11 @@ export function listenAuthChanges() {
                 await hydrateFromSession(sess);
                 sessionReady.value = true;
             } catch (e) {
-                console.warn('[auth hydrate error]', e);
+                logError('session', 'auth hydrate error', e);
             } finally {
                 sessionRefreshing.value = false;
             }
+            dispatch(event === 'TOKEN_REFRESHED' ? 'TOKEN_REFRESHED' : 'SIGNED_IN', sess);
             return;
         }
 
@@ -215,7 +252,7 @@ export function listenAuthChanges() {
         try {
             await refreshSession();
         } catch (e) {
-            console.error('[refreshSession error]', e);
+            logError('session', 'refreshSession error', e);
         }
     });