@hed-hog/core 0.0.399 → 0.0.400

package/dist/session/session.service.d.ts

@@ -14,22 +14,62 @@ export declare class SessionService {
     private readonly user;
     private readonly paginationService;
     private readonly logger;
+    /**
+     * Janela em que o refresh token ANTERIOR continua sendo aceito depois de uma
+     * rotacao.
+     *
+     * Sem ela a rotacao e um handoff sem tolerancia: se a resposta do
+     * `/auth/refresh` se perde no caminho de volta — rede caindo, aba suspensa,
+     * pod reciclado no meio de um rollout — o servidor ja girou e o cliente fica
+     * com um token que nao vale mais. Uma sessao valida de 30 dias morre por um
+     * soluco de rede, e o unico rastro e um 401 solto. A janela tambem absorve
+     * duas abas renovando ao mesmo tempo.
+     *
+     * Curta de proposito: ela existe para cobrir a corrida e a resposta perdida,
+     * nao para prolongar a vida do token.
+     */
+    private static readonly REFRESH_GRACE_MS;
+    /**
+     * Sessao aberta por um cliente OAuth externo vive menos que a de login: o
+     * refresh token esta com um terceiro. Vale na criacao E na renovacao — sem
+     * reaplicar aqui, a primeira renovacao devolvia a sessao aos 30 dias globais e
+     * o limite virava decoracao.
+     */
+    static readonly CONNECTOR_SESSION_TTL_MINUTES: number;
+    /**
+     * Tentativas de rotacao por chamada. A segunda cobre o caso de outra
+     * requisicao ter girado a sessao entre a leitura e o compare-and-swap.
+     */
+    private static readonly REFRESH_ROTATION_ATTEMPTS;
     constructor(prisma: PrismaService, security: SecurityService, setting: SettingService, token: TokenService, http: HttpService, user: UserService, paginationService: PaginationService);
-    create(locale: string, userId: number, ipAddress: string, userAgent: string, browserId?: string | null): Promise<{
+    /**
+     * `oauth` marca a sessao como pertencente a um cliente OAuth externo. Vem
+     * preenchido so pela troca do authorization code quando o cliente pediu um
+     * `resource`; o login normal continua chamando sem ele e nada muda.
+     */
+    create(locale: string, userId: number, ipAddress: string, userAgent: string, browserId?: string | null, oauth?: {
+        audience: string;
+        clientId: string;
+        ttlMinutes?: number;
+    }): Promise<{
         token: string;
         session: {
             id: number;
             user_id: number;
             user_agent: string;
-            impersonator_user_id: number | null;
             created_at: Date;
+            impersonator_user_id: number | null;
             updated_at: Date;
             hash: string;
-            browser_id: string | null;
             ip_address: string;
             revoked_at: Date | null;
             expires_at: Date;
+            browser_id: string | null;
             impersonation_reason: string | null;
+            previous_hash: string | null;
+            previous_hash_expires_at: Date | null;
+            audience: string | null;
+            oauth_client_id: string | null;
         };
     }>;
     /**
@@ -48,15 +88,19 @@ export declare class SessionService {
         id: number;
         user_id: number;
         user_agent: string;
-        impersonator_user_id: number | null;
         created_at: Date;
+        impersonator_user_id: number | null;
         updated_at: Date;
         hash: string;
-        browser_id: string | null;
         ip_address: string;
         revoked_at: Date | null;
         expires_at: Date;
+        browser_id: string | null;
         impersonation_reason: string | null;
+        previous_hash: string | null;
+        previous_hash_expires_at: Date | null;
+        audience: string | null;
+        oauth_client_id: string | null;
     }>;
     /**
      * Anexa `impersonator: { id, name }` as sessoes simuladas. Nao ha relacao
@@ -65,23 +109,75 @@ export declare class SessionService {
      * `UserService.listUserChangeLogs` com os atores.
      */
     private attachImpersonators;
+    /**
+     * Anexa `oauth_client: { client_id, name }` as sessoes abertas por um cliente
+     * OAuth externo. Mesmo padrao de `attachImpersonators`, e pela mesma razao:
+     * `oauth_client_id` e VARCHAR puro, sem FK.
+     *
+     * Existe porque sem o nome a tela de seguranca do usuario fica ILEGIVEL para
+     * esse caso: um conector fala com a API a partir da nuvem do fornecedor, entao
+     * a linha aparece com user agent que o ua-parser nao reconhece
+     * (`python-httpx/0.28.1`), sem dispositivo, e geolocalizada no pais dele. Para
+     * quem esta no Brasil, e indistinguivel de uma conta invadida.
+     */
+    private attachOAuthClients;
+    /**
+     * Gira o refresh token PRESERVANDO a identidade da sessao.
+     *
+     * A versao anterior revogava a linha e criava outra, com `id` novo. Como
+     * `TokenService.verify` valida a sessao no banco a cada request e recusa
+     * qualquer access token cuja sessao esteja revogada, o instante do refresh
+     * matava todos os access tokens em voo — na hora, e nao no `exp`. Numa tela
+     * que dispara ~10 chamadas em paralelo isso virava reacao em cadeia: cada 401
+     * disparava outro refresh, cada refresh matava os tokens dos outros. Nos logs
+     * de producao de 24/08 foram doze sessoes giradas em 18 segundos para o mesmo
+     * usuario, terminando em `Refresh rejected` e logout.
+     *
+     * Com o `id` estavel, o access token que ja saiu continua valido ate o proprio
+     * `exp`, e a rotacao deixa de ser um evento observavel pelo resto do app. De
+     * quebra a tabela para de crescer uma linha a cada 15 minutos por dispositivo.
+     */
     refresh(locale: string, refreshToken: string, ipAddress: string, userAgent: string, browserId?: string | null): Promise<{
         token: string;
         session: {
             id: number;
             user_id: number;
-            user_agent: string;
-            impersonator_user_id: number | null;
-            created_at: Date;
-            updated_at: Date;
-            hash: string;
-            browser_id: string | null;
             ip_address: string;
-            revoked_at: Date | null;
+            user_agent: string;
+            browser_id: string;
             expires_at: Date;
-            impersonation_reason: string | null;
+            audience: string;
+            oauth_client_id: string;
         };
     }>;
+    /**
+     * Casa o refresh token apresentado com a sessao: pelo hash corrente, ou pelo
+     * anterior enquanto a janela de graca estiver aberta.
+     *
+     * O limite pela janela e o que impede um token antigo qualquer de ressuscitar
+     * uma sessao — so o imediatamente anterior, e so por
+     * `REFRESH_GRACE_MS`, continua servindo.
+     */
+    /**
+     * Le a sessao de um refresh token SEM rotacionar nada.
+     *
+     * Existe porque `refresh()` encontra e gira na mesma operacao: quem precisa
+     * decidir se aceita a renovacao (o client confere? o resource confere? a sessao
+     * e de conector?) so podia fazer isso depois do compare-and-swap ja commitado —
+     * e uma recusa deixava o cliente com um token morto em 30 segundos, sem nunca
+     * receber o substituto. Validar antes e a diferenca entre negar um pedido e
+     * destruir a sessao.
+     */
+    peekByRefreshToken(refreshToken: string): Promise<{
+        id: number;
+        user_id: number;
+        impersonator_user_id: number;
+        revoked_at: Date;
+        expires_at: Date;
+        audience: string;
+        oauth_client_id: string;
+    }>;
+    private refreshTokenWhere;
     deleteRefreshTokenCookie(res: any, refreshToken: string): Promise<{
         count: number;
         userId: number;
@@ -108,15 +204,19 @@ export declare class SessionService {
         id: number;
         user_id: number;
         user_agent: string;
-        impersonator_user_id: number | null;
         created_at: Date;
+        impersonator_user_id: number | null;
         updated_at: Date;
         hash: string;
-        browser_id: string | null;
         ip_address: string;
         revoked_at: Date | null;
         expires_at: Date;
+        browser_id: string | null;
         impersonation_reason: string | null;
+        previous_hash: string | null;
+        previous_hash_expires_at: Date | null;
+        audience: string | null;
+        oauth_client_id: string | null;
     }>;
     /**
      * Enforce maximum concurrent sessions limit for a user.
@@ -128,6 +228,9 @@ export declare class SessionService {
      * @param isRotation - When true, the calling flow is replacing an existing session (refresh),
      *   not adding a new one, so no extra slot needs to be freed.
      * @param currentBrowserId - The browser_id of the session being created/refreshed.
+     * @param keepSessionId - Session that must survive: its whole browser slot is
+     *   excluded from eviction. Passed by the refresh flow, so renewing a live
+     *   session can never revoke the very session being renewed.
      */
     private enforceSessionLimit;
 }

package/dist/session/session.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session.service.d.ts","sourceRoot":"","sources":["../../src/session/session.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAanD,qBACa,cAAc;IAIvB,OAAO,CAAC,MAAM;IAEd,OAAO,CAAC,QAAQ;IAEhB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAExB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAEtB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAErB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAErB,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAfpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmC;gBAGhD,MAAM,EAAE,aAAa,EAErB,QAAQ,EAAE,eAAe,EAEhB,OAAO,EAAE,cAAc,EAEvB,KAAK,EAAE,YAAY,EAEnB,IAAI,EAAE,WAAW,EAEjB,IAAI,EAAE,WAAW,EAEjB,iBAAiB,EAAE,iBAAiB;IAGjD,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;;;;;;;;;;;;;;;;;IAuC5G;;;;;;;;;;;OAWG;IACG,mBAAmB,CACvB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,gBAAgB,EAAE,MAAM,EACxB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;;;;;;;;;;;;;;IAsBxB;;;;;OAKG;YACW,mBAAmB;IAwB3B,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;;;;;;;;;;;;;;;;;IAqG7G,wBAAwB,CAAC,GAAG,KAAA,EAAE,YAAY,EAAE,MAAM;;;;IAkClD,eAAe,CAAC,gBAAgB,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;;;;;IAmD/E,qBAAqB,CAAC,gBAAgB,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;;;;;YAmD7E,YAAY;YAmBZ,mBAAmB;IAQ3B,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAexD,iBAAiB,CAAC,MAAM,EAAE,MAAM;IAIhC,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;;;;;;;;;;;;IA0BzE;;;;;;;;;;OAUG;YACW,mBAAmB;CAmDlC"}
+{"version":3,"file":"session.service.d.ts","sourceRoot":"","sources":["../../src/session/session.service.ts"],"names":[],"mappings":"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"}

package/dist/session/session.service.js

@@ -46,7 +46,13 @@ let SessionService = SessionService_1 = class SessionService {
         this.paginationService = paginationService;
         this.logger = new common_1.Logger(SessionService_1.name);
     }
-    async create(locale, userId, ipAddress, userAgent, browserId) {
+    /**
+     * `oauth` marca a sessao como pertencente a um cliente OAuth externo. Vem
+     * preenchido so pela troca do authorization code quando o cliente pediu um
+     * `resource`; o login normal continua chamando sem ele e nada muda.
+     */
+    async create(locale, userId, ipAddress, userAgent, browserId, oauth) {
+        var _a, _b;
         if (!userId) {
             throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('session.userIdRequired', locale, 'User ID is required to create a session.'));
         }
@@ -63,17 +69,31 @@ let SessionService = SessionService_1 = class SessionService {
         const token = await this.token.createOpaqueToken();
         const hash = this.security.hashWithPepper(token);
         const maxSessions = Number(settings['max-concurrent-sessions']) || 0;
-        if (maxSessions > 0) {
+        // E pela mesma razao a sessao de conector nao DISPARA o despejo ao nascer.
+        // `createImpersonation` ja se isenta assim; aqui o efeito seria o usuario
+        // perder o celular por ter autorizado um app.
+        if (maxSessions > 0 && !oauth) {
             await this.enforceSessionLimit(userId, maxSessions, false, browserId);
         }
+        // Sessao de conector vive menos que a de login. Nao e simetria estetica: o
+        // refresh token esta com um terceiro, e 30 dias de janela para um segredo que
+        // saiu do nosso dominio e generoso demais.
+        //
+        // `||` e nao `??` em toda a cadeia: `Number(undefined)` e NaN, que passa
+        // direto por `??` e produziria um expires_at invalido.
+        const ttlMinutes = (oauth === null || oauth === void 0 ? void 0 : oauth.ttlMinutes) ||
+            Number(settings['refresh-token-expiration-minutes']) ||
+            43200;
         const session = await this.prisma.user_session.create({
             data: {
                 user_id: userId,
                 ip_address: ipAddress,
                 user_agent: userAgent,
-                expires_at: new Date(Date.now() + ((settings['refresh-token-expiration-minutes'] || 43200) * 60 * 1000)),
+                expires_at: new Date(Date.now() + ttlMinutes * 60 * 1000),
                 hash,
                 browser_id: browserId !== null && browserId !== void 0 ? browserId : null,
+                audience: (_a = oauth === null || oauth === void 0 ? void 0 : oauth.audience) !== null && _a !== void 0 ? _a : null,
+                oauth_client_id: (_b = oauth === null || oauth === void 0 ? void 0 : oauth.clientId) !== null && _b !== void 0 ? _b : null,
             },
         });
         return { token, session };
@@ -131,88 +151,197 @@ let SessionService = SessionService_1 = class SessionService {
                     : null }));
         });
     }
+    /**
+     * Anexa `oauth_client: { client_id, name }` as sessoes abertas por um cliente
+     * OAuth externo. Mesmo padrao de `attachImpersonators`, e pela mesma razao:
+     * `oauth_client_id` e VARCHAR puro, sem FK.
+     *
+     * Existe porque sem o nome a tela de seguranca do usuario fica ILEGIVEL para
+     * esse caso: um conector fala com a API a partir da nuvem do fornecedor, entao
+     * a linha aparece com user agent que o ua-parser nao reconhece
+     * (`python-httpx/0.28.1`), sem dispositivo, e geolocalizada no pais dele. Para
+     * quem esta no Brasil, e indistinguivel de uma conta invadida.
+     */
+    async attachOAuthClients(rows) {
+        const ids = Array.from(new Set(rows
+            .map((row) => row.oauth_client_id)
+            .filter((id) => typeof id === 'string' && id.length > 0)));
+        if (!ids.length) {
+            return rows.map((row) => (Object.assign(Object.assign({}, row), { oauth_client: null })));
+        }
+        const clients = await this.prisma.oauth_app_client.findMany({
+            where: { client_id: { in: ids } },
+            select: { client_id: true, name: true },
+        });
+        const byId = new Map(clients.map((client) => [client.client_id, client]));
+        return rows.map((row) => {
+            var _a;
+            return (Object.assign(Object.assign({}, row), { oauth_client: row.oauth_client_id
+                    ? // Client removido do registro ainda tem sessao viva: cai no proprio
+                        // slug, que e melhor que sumir com a informacao.
+                        ((_a = byId.get(row.oauth_client_id)) !== null && _a !== void 0 ? _a : {
+                            client_id: row.oauth_client_id,
+                            name: row.oauth_client_id,
+                        })
+                    : null }));
+        });
+    }
+    /**
+     * Gira o refresh token PRESERVANDO a identidade da sessao.
+     *
+     * A versao anterior revogava a linha e criava outra, com `id` novo. Como
+     * `TokenService.verify` valida a sessao no banco a cada request e recusa
+     * qualquer access token cuja sessao esteja revogada, o instante do refresh
+     * matava todos os access tokens em voo — na hora, e nao no `exp`. Numa tela
+     * que dispara ~10 chamadas em paralelo isso virava reacao em cadeia: cada 401
+     * disparava outro refresh, cada refresh matava os tokens dos outros. Nos logs
+     * de producao de 24/08 foram doze sessoes giradas em 18 segundos para o mesmo
+     * usuario, terminando em `Refresh rejected` e logout.
+     *
+     * Com o `id` estavel, o access token que ja saiu continua valido ate o proprio
+     * `exp`, e a rotacao deixa de ser um evento observavel pelo resto do app. De
+     * quebra a tabela para de crescer uma linha a cada 15 minutos por dispositivo.
+     */
     async refresh(locale, refreshToken, ipAddress, userAgent, browserId) {
+        var _a, _b, _c, _d, _e, _f;
         if (!refreshToken) {
             throw new common_1.UnauthorizedException((0, api_locale_1.getLocaleText)('accessDenied', locale, 'Access denied.'));
         }
         const hash = this.security.hashWithPepper(refreshToken);
-        const rawSession = await this.prisma.user_session.findFirst({
-            where: { hash },
-            select: { id: true, user_id: true, ip_address: true, user_agent: true, revoked_at: true, expires_at: true, browser_id: true, impersonator_user_id: true },
-        });
-        if (!rawSession) {
-            this.logger.warn(`[SessionRefresh] Refresh rejected: hash prefix ${hash.slice(0, 8)} not found in DB`);
-            throw new common_1.UnauthorizedException((0, api_locale_1.getLocaleText)('accessDenied', locale, 'Access denied.'));
-        }
-        if (rawSession.revoked_at !== null) {
-            this.logger.warn(`[SessionRefresh] Refresh rejected: sessionId=${rawSession.id} userId=${rawSession.user_id} revoked_at=${rawSession.revoked_at.toISOString()} hash prefix ${hash.slice(0, 8)}`);
-            throw new common_1.UnauthorizedException((0, api_locale_1.getLocaleText)('accessDenied', locale, 'Access denied.'));
-        }
-        if (rawSession.expires_at <= new Date()) {
-            this.logger.warn(`[SessionRefresh] Refresh rejected: sessionId=${rawSession.id} userId=${rawSession.user_id} expired expires_at=${rawSession.expires_at.toISOString()} hash prefix ${hash.slice(0, 8)}`);
-            throw new common_1.UnauthorizedException((0, api_locale_1.getLocaleText)('accessDenied', locale, 'Access denied.'));
-        }
-        // Simulacao de acesso e nao renovavel. `createImpersonation` ja descarta o
-        // token opaco, entao chegar aqui significa que alguem obteve o segredo por
-        // outro caminho — e renovar transformaria a janela de 30 minutos numa sessao
-        // normal de 30 dias, sem a marca de simulado.
-        if (rawSession.impersonator_user_id !== null) {
-            this.logger.warn(`[SessionRefresh] Refresh rejected: sessionId=${rawSession.id} userId=${rawSession.user_id} is an impersonation session`);
-            throw new common_1.UnauthorizedException((0, api_locale_1.getLocaleText)('accessDenied', locale, 'Access denied.'));
-        }
-        const session = {
-            id: rawSession.id,
-            user_id: rawSession.user_id,
-            ip_address: rawSession.ip_address,
-            user_agent: rawSession.user_agent,
-            browser_id: rawSession.browser_id,
-        };
         const settings = await this.setting.getSettingValues([
             'refresh-token-expiration-minutes',
             'max-concurrent-sessions',
         ]);
         const maxSessions = Number(settings['max-concurrent-sessions']) || 0;
-        if (maxSessions > 0) {
-            await this.enforceSessionLimit(session.user_id, maxSessions, true, browserId);
-        }
-        const nextRefreshToken = await this.token.createOpaqueToken();
-        const nextHash = this.security.hashWithPepper(nextRefreshToken);
-        const expiresAt = new Date(Date.now() + ((settings['refresh-token-expiration-minutes'] || 43200) * 60 * 1000));
-        const nextIpAddress = (ipAddress === null || ipAddress === void 0 ? void 0 : ipAddress.trim()) || session.ip_address || 'unknown';
-        const nextUserAgent = (userAgent === null || userAgent === void 0 ? void 0 : userAgent.trim()) || session.user_agent || 'unknown';
-        this.logger.debug(`[SessionRefresh] Starting rotation userId=${session.user_id} oldSessionId=${session.id} ip=${nextIpAddress}`);
-        const txStart = Date.now();
-        const { updateResult, newSession } = await this.prisma.$transaction(async (tx) => {
-            var _a, _b;
-            const updateResult = await tx.user_session.updateMany({
+        const ttlMinutes = Number(settings['refresh-token-expiration-minutes']) || 43200;
+        for (let attempt = 1; attempt <= SessionService_1.REFRESH_ROTATION_ATTEMPTS; attempt++) {
+            const rawSession = await this.prisma.user_session.findFirst({
+                where: this.refreshTokenWhere(hash),
+                select: { id: true, user_id: true, ip_address: true, user_agent: true, revoked_at: true, expires_at: true, browser_id: true, impersonator_user_id: true, hash: true, audience: true, oauth_client_id: true },
+            });
+            if (!rawSession) {
+                this.logger.warn(`[SessionRefresh] Refresh rejected: hash prefix ${hash.slice(0, 8)} not found in DB`);
+                throw new common_1.UnauthorizedException((0, api_locale_1.getLocaleText)('accessDenied', locale, 'Access denied.'));
+            }
+            if (rawSession.revoked_at !== null) {
+                this.logger.warn(`[SessionRefresh] Refresh rejected: sessionId=${rawSession.id} userId=${rawSession.user_id} revoked_at=${rawSession.revoked_at.toISOString()} hash prefix ${hash.slice(0, 8)}`);
+                throw new common_1.UnauthorizedException((0, api_locale_1.getLocaleText)('accessDenied', locale, 'Access denied.'));
+            }
+            if (rawSession.expires_at <= new Date()) {
+                this.logger.warn(`[SessionRefresh] Refresh rejected: sessionId=${rawSession.id} userId=${rawSession.user_id} expired expires_at=${rawSession.expires_at.toISOString()} hash prefix ${hash.slice(0, 8)}`);
+                throw new common_1.UnauthorizedException((0, api_locale_1.getLocaleText)('accessDenied', locale, 'Access denied.'));
+            }
+            // Simulacao de acesso e nao renovavel. `createImpersonation` ja descarta o
+            // token opaco, entao chegar aqui significa que alguem obteve o segredo por
+            // outro caminho — e renovar transformaria a janela de 30 minutos numa sessao
+            // normal de 30 dias, sem a marca de simulado.
+            if (rawSession.impersonator_user_id !== null) {
+                this.logger.warn(`[SessionRefresh] Refresh rejected: sessionId=${rawSession.id} userId=${rawSession.user_id} is an impersonation session`);
+                throw new common_1.UnauthorizedException((0, api_locale_1.getLocaleText)('accessDenied', locale, 'Access denied.'));
+            }
+            const nextRefreshToken = await this.token.createOpaqueToken();
+            const nextHash = this.security.hashWithPepper(nextRefreshToken);
+            const now = Date.now();
+            // Sessao de conector nao volta aos 30 dias globais so por ter sido
+            // renovada — o TTL curto e a propriedade que a distingue.
+            const effectiveTtl = rawSession.audience
+                ? Math.min(ttlMinutes, SessionService_1.CONNECTOR_SESSION_TTL_MINUTES)
+                : ttlMinutes;
+            const expiresAt = new Date(now + effectiveTtl * 60 * 1000);
+            const nextIpAddress = (ipAddress === null || ipAddress === void 0 ? void 0 : ipAddress.trim()) || rawSession.ip_address || 'unknown';
+            const nextUserAgent = (userAgent === null || userAgent === void 0 ? void 0 : userAgent.trim()) || rawSession.user_agent || 'unknown';
+            // Compare-and-swap pelo hash corrente, na MESMA linha. Se outra requisicao
+            // girou primeiro, `count` volta 0 e a proxima volta le o hash novo — em vez
+            // de devolver 401 para o perdedor da corrida, como antes.
+            const updateResult = await this.prisma.user_session.updateMany({
                 where: {
-                    id: session.id,
+                    id: rawSession.id,
                     revoked_at: null,
+                    hash: rawSession.hash,
                 },
                 data: {
-                    revoked_at: new Date(),
+                    hash: nextHash,
+                    previous_hash: rawSession.hash,
+                    previous_hash_expires_at: new Date(now + SessionService_1.REFRESH_GRACE_MS),
+                    expires_at: expiresAt,
+                    ip_address: nextIpAddress,
+                    user_agent: nextUserAgent,
+                    browser_id: (_b = (_a = rawSession.browser_id) !== null && _a !== void 0 ? _a : browserId) !== null && _b !== void 0 ? _b : null,
+                    updated_at: new Date(),
                 },
             });
-            const newSession = await tx.user_session.create({
-                data: {
-                    user_id: session.user_id,
+            if (updateResult.count === 0) {
+                this.logger.debug(`[SessionRefresh] Rotation lost the CAS sessionId=${rawSession.id} userId=${rawSession.user_id} attempt=${attempt}`);
+                continue;
+            }
+            // Depois da rotacao, nunca antes. Rodando antes, o limite podia revogar a
+            // propria sessao que estava sendo renovada e o CAS falhava sozinho. E
+            // `keepSessionId` garante que renovar nunca despeja quem esta renovando.
+            if (maxSessions > 0) {
+                await this.enforceSessionLimit(rawSession.user_id, maxSessions, true, browserId, rawSession.id);
+            }
+            this.logger.debug(`[SessionRefresh] Rotation successful userId=${rawSession.user_id} sessionId=${rawSession.id} durationMs=${Date.now() - now}`);
+            return {
+                token: nextRefreshToken,
+                session: {
+                    id: rawSession.id,
+                    user_id: rawSession.user_id,
                     ip_address: nextIpAddress,
                     user_agent: nextUserAgent,
+                    browser_id: (_d = (_c = rawSession.browser_id) !== null && _c !== void 0 ? _c : browserId) !== null && _d !== void 0 ? _d : null,
                     expires_at: expiresAt,
-                    hash: nextHash,
-                    browser_id: (_b = (_a = session.browser_id) !== null && _a !== void 0 ? _a : browserId) !== null && _b !== void 0 ? _b : null,
+                    // Quem renova precisa saber que esta renovando uma sessao de conector:
+                    // e dai que sai o `aud` do proximo access token. Sem isso a rotacao
+                    // devolveria um token de sessao comum e desfaria o vinculo.
+                    audience: (_e = rawSession.audience) !== null && _e !== void 0 ? _e : null,
+                    oauth_client_id: (_f = rawSession.oauth_client_id) !== null && _f !== void 0 ? _f : null,
                 },
-            });
-            return { updateResult, newSession };
-        });
-        if (updateResult.count === 0) {
-            this.logger.warn(`[SessionRefresh] Race condition detected: userId=${session.user_id} oldSessionId=${session.id} already rotated by another request (durationMs=${Date.now() - txStart})`);
-            throw new common_1.UnauthorizedException((0, api_locale_1.getLocaleText)('accessDenied', locale, 'Access denied.'));
+            };
         }
-        this.logger.debug(`[SessionRefresh] Rotation successful userId=${session.user_id} oldSessionId=${session.id} newSessionId=${newSession.id} durationMs=${Date.now() - txStart}`);
+        this.logger.warn(`[SessionRefresh] Rotation gave up after ${SessionService_1.REFRESH_ROTATION_ATTEMPTS} attempts: hash prefix ${hash.slice(0, 8)}`);
+        throw new common_1.UnauthorizedException((0, api_locale_1.getLocaleText)('accessDenied', locale, 'Access denied.'));
+    }
+    /**
+     * Casa o refresh token apresentado com a sessao: pelo hash corrente, ou pelo
+     * anterior enquanto a janela de graca estiver aberta.
+     *
+     * O limite pela janela e o que impede um token antigo qualquer de ressuscitar
+     * uma sessao — so o imediatamente anterior, e so por
+     * `REFRESH_GRACE_MS`, continua servindo.
+     */
+    /**
+     * Le a sessao de um refresh token SEM rotacionar nada.
+     *
+     * Existe porque `refresh()` encontra e gira na mesma operacao: quem precisa
+     * decidir se aceita a renovacao (o client confere? o resource confere? a sessao
+     * e de conector?) so podia fazer isso depois do compare-and-swap ja commitado —
+     * e uma recusa deixava o cliente com um token morto em 30 segundos, sem nunca
+     * receber o substituto. Validar antes e a diferenca entre negar um pedido e
+     * destruir a sessao.
+     */
+    async peekByRefreshToken(refreshToken) {
+        if (!refreshToken)
+            return null;
+        const hash = this.security.hashWithPepper(refreshToken);
+        return this.prisma.user_session.findFirst({
+            where: this.refreshTokenWhere(hash),
+            select: {
+                id: true,
+                user_id: true,
+                revoked_at: true,
+                expires_at: true,
+                audience: true,
+                oauth_client_id: true,
+                impersonator_user_id: true,
+            },
+        });
+    }
+    refreshTokenWhere(hash) {
         return {
-            token: nextRefreshToken,
-            session: newSession,
+            OR: [
+                { hash },
+                { previous_hash: hash, previous_hash_expires_at: { gt: new Date() } },
+            ],
         };
     }
     async deleteRefreshTokenCookie(res, refreshToken) {
@@ -222,20 +351,18 @@ let SessionService = SessionService_1 = class SessionService {
             return { count: 0, userId: null };
         }
         const hash = this.security.hashWithPepper(refreshToken);
+        // Aceita tambem o hash anterior dentro da janela de graca: sair da conta com
+        // um token que acabou de girar tem de derrubar a sessao de verdade, e nao
+        // devolver sucesso deixando-a viva.
+        const where = Object.assign({ revoked_at: null }, this.refreshTokenWhere(hash));
         const session = await this.prisma.user_session.findFirst({
-            where: {
-                revoked_at: null,
-                hash,
-            },
+            where,
             select: {
                 user_id: true,
             },
         });
         const result = await this.prisma.user_session.updateMany({
-            where: {
-                revoked_at: null,
-                hash,
-            },
+            where,
             data: {
                 revoked_at: new Date(),
             },
@@ -277,7 +404,7 @@ let SessionService = SessionService_1 = class SessionService {
                 return Object.assign(Object.assign({}, s), { location });
             }));
             return {
-                data: await this.attachImpersonators(itemsWithLocation),
+                data: await this.attachOAuthClients(await this.attachImpersonators(itemsWithLocation)),
                 total: paginate.total || 0,
                 lastPage: Math.ceil((paginate.total || 0) / (paginate.pageSize || 1)),
                 page: (_a = paginate.page) !== null && _a !== void 0 ? _a : 1,
@@ -320,7 +447,7 @@ let SessionService = SessionService_1 = class SessionService {
                 return Object.assign(Object.assign({}, s), { location });
             }));
             return {
-                data: await this.attachImpersonators(itemsWithLocation),
+                data: await this.attachOAuthClients(await this.attachImpersonators(itemsWithLocation)),
                 total: paginate.total || 0,
                 lastPage: Math.ceil((paginate.total || 0) / (paginate.pageSize || 1)),
                 page: (_a = paginate.page) !== null && _a !== void 0 ? _a : 1,
@@ -404,8 +531,11 @@ let SessionService = SessionService_1 = class SessionService {
      * @param isRotation - When true, the calling flow is replacing an existing session (refresh),
      *   not adding a new one, so no extra slot needs to be freed.
      * @param currentBrowserId - The browser_id of the session being created/refreshed.
+     * @param keepSessionId - Session that must survive: its whole browser slot is
+     *   excluded from eviction. Passed by the refresh flow, so renewing a live
+     *   session can never revoke the very session being renewed.
      */
-    async enforceSessionLimit(userId, maxSessions, isRotation = false, currentBrowserId) {
+    async enforceSessionLimit(userId, maxSessions, isRotation = false, currentBrowserId, keepSessionId) {
         var _a;
         const activeSessions = await this.prisma.user_session.findMany({
             where: {
@@ -415,6 +545,11 @@ let SessionService = SessionService_1 = class SessionService {
                 // Simulacao de acesso nao consome slot: ela nasce com browser_id nulo e
                 // seria contada como slot proprio, despejando uma sessao real do alvo.
                 impersonator_user_id: null,
+                // Sessao de cliente OAuth externo, pelo mesmo motivo: um cliente MCP nao
+                // manda X-Browser-ID, entao cada conexao viraria um slot proprio e
+                // derrubaria um dispositivo de verdade do usuario — que so queria ligar o
+                // Claude. Conector nao e navegador.
+                audience: null,
             },
             orderBy: { created_at: 'asc' },
             select: { id: true, browser_id: true }
@@ -428,6 +563,15 @@ let SessionService = SessionService_1 = class SessionService {
         }
         const slots = Array.from(slotMap.values());
         const currentSlotCount = slots.length;
+        // O slot de quem esta renovando nunca entra na fila de despejo: renovar uma
+        // sessao viva nao pode derrubar a propria sessao. Sem isto, um usuario com
+        // mais slots que o limite era deslogado no proximo refresh — a rotacao
+        // revogava a si mesma e o compare-and-swap logo em seguida nao achava a
+        // linha.
+        const protectedSlot = typeof keepSessionId === 'number'
+            ? slots.find((slot) => slot.ids.includes(keepSessionId))
+            : undefined;
+        const evictable = slots.filter((slot) => slot !== protectedSlot);
         // A new browser slot is created only when:
         // - it's not a rotation (rotation keeps the same slot), AND
         // - the current browser doesn't already have an active slot
@@ -437,10 +581,13 @@ let SessionService = SessionService_1 = class SessionService {
         this.logger.debug(`[SessionLimit] userId=${userId} slots=${currentSlotCount} maxSessions=${maxSessions} isRotation=${isRotation} browserId=${currentBrowserId !== null && currentBrowserId !== void 0 ? currentBrowserId : 'null'} newSlot=${isNewSlot} toRevoke=${Math.max(0, slotsToRevoke)}`);
         if (slotsToRevoke > 0) {
             const sessionIdsToRevoke = [];
-            for (let i = 0; i < slotsToRevoke; i++) {
-                sessionIdsToRevoke.push(...slots[i].ids);
+            for (let i = 0; i < Math.min(slotsToRevoke, evictable.length); i++) {
+                sessionIdsToRevoke.push(...evictable[i].ids);
+            }
+            if (sessionIdsToRevoke.length === 0) {
+                return;
             }
-            this.logger.warn(`[SessionLimit] Revoking ${slotsToRevoke} oldest browser slot(s) for userId=${userId}: sessions [${sessionIdsToRevoke.join(',')}]`);
+            this.logger.warn(`[SessionLimit] Revoking ${sessionIdsToRevoke.length} session(s) in the oldest browser slot(s) for userId=${userId}: [${sessionIdsToRevoke.join(',')}]`);
             await this.prisma.user_session.updateMany({
                 where: { id: { in: sessionIdsToRevoke } },
                 data: { revoked_at: new Date() }
@@ -449,6 +596,33 @@ let SessionService = SessionService_1 = class SessionService {
     }
 };
 exports.SessionService = SessionService;
+/**
+ * Janela em que o refresh token ANTERIOR continua sendo aceito depois de uma
+ * rotacao.
+ *
+ * Sem ela a rotacao e um handoff sem tolerancia: se a resposta do
+ * `/auth/refresh` se perde no caminho de volta — rede caindo, aba suspensa,
+ * pod reciclado no meio de um rollout — o servidor ja girou e o cliente fica
+ * com um token que nao vale mais. Uma sessao valida de 30 dias morre por um
+ * soluco de rede, e o unico rastro e um 401 solto. A janela tambem absorve
+ * duas abas renovando ao mesmo tempo.
+ *
+ * Curta de proposito: ela existe para cobrir a corrida e a resposta perdida,
+ * nao para prolongar a vida do token.
+ */
+SessionService.REFRESH_GRACE_MS = 30000;
+/**
+ * Sessao aberta por um cliente OAuth externo vive menos que a de login: o
+ * refresh token esta com um terceiro. Vale na criacao E na renovacao — sem
+ * reaplicar aqui, a primeira renovacao devolvia a sessao aos 30 dias globais e
+ * o limite virava decoracao.
+ */
+SessionService.CONNECTOR_SESSION_TTL_MINUTES = 7 * 24 * 60;
+/**
+ * Tentativas de rotacao por chamada. A segunda cobre o caso de outra
+ * requisicao ter girado a sessao entre a leitura e o compare-and-swap.
+ */
+SessionService.REFRESH_ROTATION_ATTEMPTS = 2;
 exports.SessionService = SessionService = SessionService_1 = __decorate([
     (0, common_1.Injectable)(),
     __param(1, (0, common_1.Inject)((0, common_1.forwardRef)(() => security_service_1.SecurityService))),