@hed-hog/core 0.0.399 → 0.0.400

package/src/ai-instruction/ai-instruction.sort.ts

@@ -0,0 +1,32 @@
+import { defineSortable } from '@hed-hog/api-pagination';
+
+/**
+ * Campos ordenáveis de `ai_instruction` (`AiInstructionService.list`).
+ *
+ * `model`/`temperature`/`max_tokens` (coluna "Parâmetros" da tela, concatenados
+ * em `renderModelParams`) e o estado calculado a partir do registry + flags
+ * (coluna "Estado") ficam de fora: nenhum dos dois é uma coluna única — não há
+ * como declarar um `orderBy` que corresponda ao que a célula mostra.
+ *
+ * Desempate: o `$queryRaw` antigo tinha `ORDER BY layer, slug` fixo (as duas
+ * sempre ascendentes, sem opção de inverter). O default abaixo reproduz isso
+ * com `default: 'layer', defaultOrder: 'asc'` e `tiebreaker: 'slug'` fixado em
+ * `'asc'` (em vez do `id` padrão do `defineSortable`) — mais fiel ao
+ * comportamento anterior do que cair no id como desempate.
+ */
+export const AI_INSTRUCTION_SORT = defineSortable(
+  {
+    slug: true,
+    name: true,
+    layer: true,
+    module_slug: true,
+    version: true,
+    updated_at: { initialOrder: 'desc' },
+  },
+  {
+    default: 'layer',
+    defaultOrder: 'asc',
+    tiebreaker: 'slug',
+    tiebreakerOrder: 'asc',
+  },
+);

package/src/auth/auth.module.ts

@@ -8,6 +8,7 @@ import { JwtModule } from '@nestjs/jwt';
 import cookieParser from 'cookie-parser';
 import { ChallengeModule } from '../challenge/challenge.module';
 import { ChallengeService } from '../challenge/challenge.service';
+import { OAuthMetadataService } from '../authorize/oauth-metadata.service';
 import { MailSentModule } from '../mail-sent/mail-sent.module';
 import { MailModule } from '../mail/mail.module';
 import { SecurityModule } from '../security/security.module';
@@ -88,12 +89,18 @@ import { AuthGuard } from './guards/auth.guard';
     AuthService,
     TokenService,
     ChallengeService,
+    // Declarado aqui, e nao em AuthorizeModule (onde o arquivo mora), porque o
+    // AuthGuard abaixo e um APP_GUARD deste modulo: um provider de outro modulo
+    // so seria resolvido importando AuthorizeModule, que por sua vez importa
+    // AuthModule — circulo. Como este modulo e @Global, exportar aqui atende
+    // tambem o McpAuthGuard, sem ninguem precisar importar nada.
+    OAuthMetadataService,
     {
       provide: APP_GUARD,
       useClass: AuthGuard,
     },
   ],
-  exports: [AuthService],
+  exports: [AuthService, OAuthMetadataService],
 })
 export class AuthModule {
   configure(consumer: MiddlewareConsumer) {

package/src/auth/auth.service.spec.ts

@@ -63,6 +63,7 @@ const makeDeps = () => {
     setRefreshTokenCookie: jest.fn(),
   };
   const session = {
+    peekByRefreshToken: jest.fn<any>().mockResolvedValue({ id: 2, user_id: 9, audience: null, oauth_client_id: null, revoked_at: null, expires_at: new Date('2099-01-01') }),
     create: jest.fn(),
     refresh: jest.fn(),
     deleteRefreshTokenCookie: jest.fn(),
@@ -120,7 +121,7 @@ describe('AuthService', () => {
 
       const result = await service.getAuthenticationPayload('pt-BR', 1, '1.2.3.4', 'UA', 'browser-1');
 
-      expect(deps.session.create).toHaveBeenCalledWith('pt-BR', 1, '1.2.3.4', 'UA', 'browser-1');
+      expect(deps.session.create).toHaveBeenCalledWith('pt-BR', 1, '1.2.3.4', 'UA', 'browser-1', undefined);
       expect(deps.prisma.user.update).toHaveBeenCalledWith({
         where: { id: 1 },
         data: { last_login_at: expect.any(Date) },
@@ -202,6 +203,37 @@ describe('AuthService', () => {
       ).rejects.toThrow(BadRequestException);
     });
 
+    it('recusa a senha de credencial revogada', async () => {
+      // A revogação é o que o convite de acesso enterprise usa para trocar
+      // "autorize o acesso" por "crie sua conta e defina a senha"
+      // (`notifyAdminAccess` com `resetPassword`). Antes deste filtro, o login
+      // ignorava `revoked_at` e a senha antiga continuava entrando — enquanto o
+      // "esqueci minha senha", que sempre exigiu credencial ativa, dizia que a
+      // conta não tinha senha.
+      const { service, deps } = makeService();
+      deps.user.findUserByEmail.mockResolvedValue({
+        id: 1,
+        user_credential: [{ type: 'password', revoked_at: new Date() }],
+        user_identifier: [{ type: 'email', value: 'a@b.com' }],
+      });
+      deps.security.validatePassword.mockResolvedValue(false);
+
+      await expect(
+        service.loginWithEmailAndPassword({}, 'pt-BR', '1.1.1.1', 'UA', {
+          email: 'a@b.com',
+          password: 'a-senha-revogada',
+        } as any),
+      ).rejects.toThrow(BadRequestException);
+
+      // Sem credencial ativa não há o que verificar: a lista chega vazia, e é isso
+      // que garante que nenhum hash revogado é comparado.
+      expect(deps.security.validatePassword).toHaveBeenCalledWith(
+        'pt-BR',
+        [],
+        'a-senha-revogada',
+      );
+    });
+
     it('retorna requiresMfa quando existem métodos MFA verificados, enviando código para emails MFA', async () => {
       const { service, deps } = makeService();
       deps.user.findUserByEmail.mockResolvedValue({
@@ -680,6 +712,81 @@ describe('AuthService', () => {
         session: { id: 2, user_id: 9 },
       });
     });
+
+    // Sem esta recusa, um cliente externo trocaria o refresh token restrito por
+    // uma sessao com acesso a API inteira, e o audience binding nao valeria nada.
+    it('recusa renovar uma sessao de conector (com audience)', async () => {
+      const { service, deps } = makeService();
+      deps.session.peekByRefreshToken.mockResolvedValue({
+        id: 2,
+        user_id: 9,
+        audience: 'https://hub-api.example.com/mcp',
+        oauth_client_id: 'claude-connector',
+        revoked_at: null,
+        expires_at: new Date('2099-01-01'),
+      });
+
+      await expect(
+        service.refreshAccessToken('pt-BR', 'connector-refresh', '1.1.1.1', 'UA'),
+      ).rejects.toThrow(UnauthorizedException);
+
+      expect(deps.token.createAccessToken).not.toHaveBeenCalled();
+    });
+
+    /**
+     * REGRESSAO: a recusa acontecia DEPOIS de session.refresh(), que ja commitou
+     * o compare-and-swap — o cliente ficava com um token morto em 30s e sem
+     * substituto. Negar um pedido nao pode destruir a sessao.
+     */
+    it('nao gira o refresh token quando vai recusar', async () => {
+      const { service, deps } = makeService();
+      deps.session.peekByRefreshToken.mockResolvedValue({
+        id: 2,
+        user_id: 9,
+        audience: 'https://hub-api.example.com/mcp',
+        oauth_client_id: 'claude-connector',
+        revoked_at: null,
+        expires_at: new Date('2099-01-01'),
+      });
+
+      await expect(
+        service.refreshAccessToken('pt-BR', 'connector-refresh', '1.1.1.1', 'UA'),
+      ).rejects.toThrow(UnauthorizedException);
+
+      expect(deps.session.refresh).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('getAuthenticationPayload - fluxo OAuth com resource', () => {
+    it('emite aud, iss, scope e cid e marca a sessao', async () => {
+      const { service, deps } = makeService();
+      deps.session.create.mockResolvedValue({
+        token: 'refresh-token',
+        session: { id: 5, expires_at: new Date('2026-01-02') },
+      });
+      deps.token.createAccessToken.mockResolvedValue('access-token');
+
+      await service.getAuthenticationPayload('pt-BR', 1, '1.2.3.4', 'UA', null, {
+        audience: 'https://hub-api.example.com/mcp',
+        scope: 'mcp',
+        clientId: 'claude-connector',
+        issuer: 'https://hub-api.example.com',
+        ttlMinutes: 10080,
+      });
+
+      expect(deps.token.createAccessToken).toHaveBeenCalledWith({
+        sub: 1,
+        sessionId: 5,
+        aud: 'https://hub-api.example.com/mcp',
+        iss: 'https://hub-api.example.com',
+        scope: 'mcp',
+        cid: 'claude-connector',
+      });
+      expect(deps.session.create).toHaveBeenCalledWith(
+        'pt-BR', 1, '1.2.3.4', 'UA', null,
+        { audience: 'https://hub-api.example.com/mcp', clientId: 'claude-connector', ttlMinutes: 10080 },
+      );
+    });
   });
 
   describe('forgotPassword / logout', () => {

package/src/auth/auth.service.ts

@@ -24,7 +24,7 @@ import { SessionService } from '../session/session.service';
 import { SettingService } from '../setting/setting.service';
 import { TokenService } from '../token/token.service';
 import { UserDeviceService } from '../user-device/user-device.service';
-import { hasPendingPasswordReset } from '../user/user-credential.util';
+import { hasPendingPasswordReset, isActivePasswordCredential } from '../user/user-credential.util';
 import { CreateWithEmailAndPasswordDTO } from '../user/dto/create-with-email-and-password.dto';
 import { UserService } from '../user/user.service';
 import { buildSecurityEventVars } from '../utils/security-event-vars';
@@ -57,9 +57,40 @@ export class AuthService {
     private readonly userDevice: UserDeviceService,
   ) { }
 
-  async getAuthenticationPayload(locale: string, userId: number, ipAddress: string, userAgent: string, browserId?: string | null) {
-    const { token: refreshToken, session } = await this.session.create(locale, userId, ipAddress, userAgent, browserId);
-    const payload = { sub: userId, sessionId: session.id };
+  /**
+   * `oauth` so vem preenchido quando a troca do authorization code pediu um
+   * `resource` (RFC 8707). Nesse caso o access token nasce amarrado aquele
+   * recurso — e o TokenService passa a recusa-lo em qualquer outro lugar. Sem o
+   * parametro, o token e o de sempre: sem `aud`, valido na API inteira.
+   */
+  async getAuthenticationPayload(
+    locale: string,
+    userId: number,
+    ipAddress: string,
+    userAgent: string,
+    browserId?: string | null,
+    oauth?: { audience: string; scope: string; clientId: string; issuer: string; ttlMinutes?: number },
+  ) {
+    const { token: refreshToken, session } = await this.session.create(
+      locale,
+      userId,
+      ipAddress,
+      userAgent,
+      browserId,
+      oauth
+        ? { audience: oauth.audience, clientId: oauth.clientId, ttlMinutes: oauth.ttlMinutes }
+        : undefined,
+    );
+    const payload = oauth
+      ? {
+          sub: userId,
+          sessionId: session.id,
+          aud: oauth.audience,
+          iss: oauth.issuer,
+          scope: oauth.scope,
+          cid: oauth.clientId,
+        }
+      : { sub: userId, sessionId: session.id };
     const accessToken = await this.token.createAccessToken(payload);
     await this.prisma.user.update({ where: { id: userId }, data: { last_login_at: new Date() } });
 
@@ -525,7 +556,11 @@ export class AuthService {
 
     if (!user) throw new BadRequestException(getLocaleText('accessDenied', locale, 'Access denied.'));
 
-    const credentials = (user as unknown as User).user_credential?.filter((c) => c.type === 'password') || [];
+    // Revogada não vale: sem o `revoked_at` aqui, revogar a senha (o que o convite
+    // de acesso enterprise faz para forçar a definição de uma nova) não impedia o
+    // login com a senha antiga. Mesmo critério de `hasPasswordCredential`, que é
+    // o que decide se o "esqueci minha senha" pode seguir.
+    const credentials = (user as unknown as User).user_credential?.filter(isActivePasswordCredential) || [];
 
     const identifier = user.user_identifier?.find((i) => i.type === 'email' && i.value === email);
 
@@ -692,6 +727,13 @@ export class AuthService {
     };
   }
 
+  /**
+   * POST /auth/refresh e publico e devolve um token SEM `aud`. Se aceitasse o
+   * refresh token de um conector, o cliente externo trocaria seu token restrito
+   * por uma sessao com acesso a API inteira e todo o audience binding viraria
+   * enfeite. A renovacao dele e o grant_type=refresh_token do /auth/token, que
+   * reaplica o `aud`.
+   */
   async refreshAccessToken(locale: string, refreshToken: string, ipAddress: string, userAgent: string, browserId?: string | null) {
 
     if (!refreshToken) {
@@ -701,6 +743,18 @@ export class AuthService {
 
     this.logger.debug(`[AuthService] refreshAccessToken ip=${ipAddress} ua=${userAgent?.slice(0, 40)}`);
 
+    // ANTES de girar. `session.refresh()` commita a rotacao assim que roda, com
+    // apenas 30s de graca para o token anterior — recusar depois dela deixaria o
+    // cliente sem o token novo e com o antigo prestes a morrer, ou seja,
+    // destruiria a sessao em vez de negar o pedido.
+    const existing = await this.session.peekByRefreshToken(refreshToken);
+    if (existing?.audience) {
+      this.logger.warn(
+        `[AuthService] refreshAccessToken rejected: sessionId=${existing.id} userId=${existing.user_id} belongs to resource ${existing.audience}`,
+      );
+      throw new UnauthorizedException(getLocaleText('accessDenied', locale, 'Access denied.'));
+    }
+
     const { session, token } = await this.session.refresh(
       locale,
       refreshToken,

package/src/auth/guards/auth.guard.ts

@@ -11,6 +11,7 @@ import {
 import { Reflector } from '@nestjs/core';
 import { Request } from 'express';
 import { ALLOW_MCP_TOKEN } from '../../mcp/decorators/allow-mcp-token.decorator';
+import { OAuthMetadataService } from '../../authorize/oauth-metadata.service';
 import { SecurityService } from '../../security/security.service';
 import { TokenService } from '../../token/token.service';
 
@@ -23,6 +24,7 @@ export class AuthGuard implements CanActivate {
     private reflector: Reflector,
     private prisma: PrismaService,
     private security: SecurityService,
+    private oauthMetadata: OAuthMetadataService,
   ) { }
 
   async canActivate(context: ExecutionContext): Promise<boolean> {
@@ -89,7 +91,13 @@ export class AuthGuard implements CanActivate {
     }
 
     try {
-      const payload = await this.token.verify(locale, token);
+      // So o /mcp e um "recurso" com audiencia propria. Em todo o resto o terceiro
+      // argumento fica ausente de proposito: e a ausencia que faz um token de
+      // conector ser recusado no REST.
+      const allowedAudience = allowMcpToken
+        ? await this.oauthMetadata.getMcpResource()
+        : undefined;
+      const payload = await this.token.verify(locale, token, allowedAudience);
 
       request['auth'] = payload;
     } catch (error) {

package/src/authorize/authorize.controller.ts

@@ -4,16 +4,23 @@ import {
   Body,
   Controller,
   Get,
+  Header,
   Headers,
   Inject,
   Ip,
   Post,
   Query,
+  Res,
+  UseFilters,
   UseGuards,
   forwardRef,
 } from '@nestjs/common';
 import { Throttle, ThrottlerGuard } from '@nestjs/throttler';
+import type { Response } from 'express';
+import { OAuthError } from './authorize.errors';
 import { AuthorizeService } from './authorize.service';
+import { OAuthMetadataService } from './oauth-metadata.service';
+import { OAuthExceptionFilter } from './oauth-exception.filter';
 import { AuthorizeInfoDTO } from './dto/authorize-info.dto';
 import { ConsentDTO } from './dto/consent.dto';
 import { TokenDTO } from './dto/token.dto';
@@ -21,18 +28,87 @@ import { TokenDTO } from './dto/token.dto';
 /**
  * Endpoints do fluxo Authorization Code + PKCE.
  *
- * Note o que NÃO existe aqui: um `GET /auth/authorize` que redireciona. O
- * redirect final é feito pelo browser, na página de consent do admin, depois do
- * POST /auth/authorize/consent. Assim toda a validação fica no servidor e o
- * `code` não passa pelo mecanismo de redirect do Nest (nem pelos seus logs).
+ * O `GET /auth/authorize` daqui NÃO emite o `code`: ele valida e redireciona para
+ * a tela de consent do admin, que é quem faz o redirect final depois do
+ * `POST /auth/authorize/consent`. A restrição original continua valendo — o
+ * `code` nunca passa pelo mecanismo de redirect do Nest, nem pelos seus logs.
+ *
+ * Ele existe porque um cliente OAuth padrão (o conector do Claude) espera um
+ * `authorization_endpoint` na mesma origem do `issuer`, e porque a validação de
+ * `response_type`, `scope` e `resource` tem que acontecer no servidor, antes de
+ * qualquer render — um erro precisa voltar como `error=` na query, e não como uma
+ * tela morta.
  */
 @Controller('auth')
 export class AuthorizeController {
   constructor(
     @Inject(forwardRef(() => AuthorizeService))
     private readonly service: AuthorizeService,
+    @Inject(forwardRef(() => OAuthMetadataService))
+    private readonly metadata: OAuthMetadataService,
   ) {}
 
+  /**
+   * O authorization endpoint anunciado nos metadados.
+   *
+   * A ordem de validação é normativa (RFC 6749 §4.1.2.1): `client_id` e
+   * `redirect_uri` primeiro, e falha neles NÃO redireciona — sem um redirect_uri
+   * validado, redirecionar seria mandar o usuário para onde o atacante pediu.
+   * Tudo o mais volta para o cliente como `error` na query.
+   */
+  @Public()
+  @UseGuards(ThrottlerGuard)
+  @Throttle({ default: { limit: 30, ttl: 60000 } })
+  @UseFilters(OAuthExceptionFilter)
+  @Get('authorize')
+  async authorize(@Query() query: AuthorizeInfoDTO, @Res() res: Response) {
+    try {
+      await this.service.getAuthorizationInfo({
+        clientId: query.client_id,
+        redirectUri: query.redirect_uri,
+        scope: query.scope,
+        codeChallenge: query.code_challenge,
+        codeChallengeMethod: query.code_challenge_method,
+        responseType: query.response_type,
+        resource: query.resource,
+      });
+    } catch (error) {
+      if (error instanceof OAuthError && error.redirectable) {
+        return res.redirect(
+          302,
+          await this.buildErrorRedirect(query, error),
+        );
+      }
+      throw error;
+    }
+
+    // Só parâmetros validados seguem para a tela. O `code` é emitido lá, pelo
+    // consent, e volta por um redirect do browser — não por este.
+    const consentBase = await this.metadata.getConsentUiBase();
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== undefined && value !== null && value !== '') {
+        params.set(key, String(value));
+      }
+    }
+
+    return res.redirect(302, `${consentBase}/auth/authorize?${params.toString()}`);
+  }
+
+  private async buildErrorRedirect(
+    query: AuthorizeInfoDTO,
+    error: OAuthError,
+  ): Promise<string> {
+    const target = new URL(query.redirect_uri);
+    target.searchParams.set('error', error.code);
+    target.searchParams.set('error_description', error.description);
+    if (query.state) target.searchParams.set('state', query.state);
+    // RFC 9207: vai também no erro, e o cliente valida antes de exibir qualquer
+    // coisa. Anunciamos `authorization_response_iss_parameter_supported`.
+    target.searchParams.set('iss', await this.metadata.getIssuer());
+    return target.toString();
+  }
+
   /**
    * Metadados para a tela de consent. Público: a página precisa validar os
    * parâmetros e mostrar de quem é o app ANTES de exigir login.
@@ -42,13 +118,32 @@ export class AuthorizeController {
   @Throttle({ default: { limit: 30, ttl: 60000 } })
   @Get('authorize/info')
   async authorizeInfo(@Query() query: AuthorizeInfoDTO) {
-    return this.service.getAuthorizationInfo({
-      clientId: query.client_id,
-      redirectUri: query.redirect_uri,
-      scope: query.scope,
-      codeChallenge: query.code_challenge,
-      codeChallengeMethod: query.code_challenge_method,
-    });
+    try {
+      return await this.service.getAuthorizationInfo({
+        clientId: query.client_id,
+        redirectUri: query.redirect_uri,
+        scope: query.scope,
+        codeChallenge: query.code_challenge,
+        codeChallengeMethod: query.code_challenge_method,
+        responseType: query.response_type,
+        resource: query.resource,
+      });
+    } catch (error) {
+      // Erro redirecionável volta para o cliente pelas mãos da tela, e o RFC 9207
+      // exige `iss` também nele. Mas a tela só aprende o issuer no caminho de
+      // SUCESSO desta chamada — num erro ela redirecionaria sem o parâmetro, e um
+      // cliente que o valide (nós anunciamos suportá-lo) rejeita a resposta
+      // inteira. Então o issuer viaja junto do erro.
+      if (error instanceof OAuthError && error.redirectable) {
+        throw new OAuthError(
+          error.code,
+          error.description,
+          true,
+          await this.metadata.getIssuer(),
+        );
+      }
+      throw error;
+    }
   }
 
   /** O usuário logado aprova. O code sai vinculado a ele. */
@@ -64,6 +159,8 @@ export class AuthorizeController {
       scope: body.scope,
       codeChallenge: body.code_challenge,
       codeChallengeMethod: body.code_challenge_method,
+      responseType: body.response_type,
+      resource: body.resource,
     });
 
     return { code };
@@ -79,6 +176,11 @@ export class AuthorizeController {
   @Public()
   @UseGuards(ThrottlerGuard)
   @Throttle({ default: { limit: 20, ttl: 60000 } })
+  @UseFilters(OAuthExceptionFilter)
+  // RFC 6749 5.1: a resposta carrega credenciais e nao pode ser cacheada. O
+  // filtro ja poe isto nos erros; aqui vale para o sucesso.
+  @Header('Cache-Control', 'no-store')
+  @Header('Pragma', 'no-cache')
   @Post('token')
   async token(
     @Body() body: TokenDTO,
@@ -87,11 +189,24 @@ export class AuthorizeController {
     @Headers('user-agent') userAgent: string,
     @Headers('x-browser-id') browserId: string,
   ) {
+    if (body.grant_type === 'refresh_token') {
+      return this.service.exchangeRefreshToken({
+        refreshToken: body.refresh_token,
+        clientId: body.client_id,
+        resource: body.resource,
+        locale,
+        ipAddress,
+        userAgent,
+        browserId: browserId || null,
+      });
+    }
+
     return this.service.exchangeCode({
       code: body.code,
       codeVerifier: body.code_verifier,
       clientId: body.client_id,
       redirectUri: body.redirect_uri,
+      resource: body.resource,
       locale,
       ipAddress,
       userAgent,

package/src/authorize/authorize.errors.ts

@@ -0,0 +1,55 @@
+import { BadRequestException } from '@nestjs/common';
+
+/**
+ * Códigos de erro do RFC 6749 §4.1.2.1 e §5.2, mais o `invalid_target` do
+ * RFC 8707.
+ */
+export type OAuthErrorCode =
+  | 'invalid_request'
+  | 'invalid_client'
+  | 'invalid_grant'
+  | 'unauthorized_client'
+  | 'unsupported_grant_type'
+  | 'unsupported_response_type'
+  | 'invalid_scope'
+  | 'invalid_target'
+  | 'access_denied'
+  | 'login_required'
+  | 'server_error';
+
+/**
+ * Erro do fluxo OAuth.
+ *
+ * `redirectable` decide o que acontece com ele, e a distinção é normativa
+ * (RFC 6749 §4.1.2.1): erro de `client_id` ou de `redirect_uri` **não** pode
+ * voltar para o `redirect_uri` — se ele não foi validado, redirecionar seria
+ * mandar o usuário para onde o atacante pediu. Todo o resto volta para o cliente
+ * como `error` na query, que é como ele descobre o que fez de errado.
+ */
+export class OAuthError extends BadRequestException {
+  // Herda de BadRequestException, e nao de HttpException direto: todo erro OAuth
+  // de requisicao e um 400, e manter a hierarquia preserva qualquer `catch` que
+  // ja exista para BadRequestException — inclusive os testes que descrevem o
+  // comportamento anterior.
+  constructor(
+    readonly code: OAuthErrorCode,
+    readonly description: string,
+    readonly redirectable = false,
+    /**
+     * Só acompanha erro redirecionável: é o `iss` que a tela precisa devolver ao
+     * cliente junto do erro (RFC 9207). No caminho de sucesso ela já o recebe em
+     * `getAuthorizationInfo`.
+     */
+    readonly issuer?: string,
+  ) {
+    super({
+      error: code,
+      error_description: description,
+      redirectable,
+      ...(issuer ? { issuer } : {}),
+      // `message` fica junto porque os clientes ja registrados leem esse campo
+      // nas respostas de erro de hoje. Tirar seria uma quebra silenciosa.
+      message: description,
+    });
+  }
+}

package/src/authorize/authorize.module.ts

@@ -2,8 +2,11 @@ import { PrismaModule } from '@hed-hog/api-prisma';
 import { Module, forwardRef } from '@nestjs/common';
 import { AuthModule } from '../auth/auth.module';
 import { SecurityModule } from '../security/security.module';
+import { SessionModule } from '../session/session.module';
+import { TokenModule } from '../token/token.module';
 import { AuthorizeController } from './authorize.controller';
 import { AuthorizeService } from './authorize.service';
+import { WellKnownController } from './well-known.controller';
 
 /**
  * Separado de OAuthModule de propósito: lá o HedHog é *client* de IdPs externos
@@ -15,8 +18,10 @@ import { AuthorizeService } from './authorize.service';
     forwardRef(() => PrismaModule),
     forwardRef(() => SecurityModule),
     forwardRef(() => AuthModule),
+    forwardRef(() => SessionModule),
+    forwardRef(() => TokenModule),
   ],
-  controllers: [AuthorizeController],
+  controllers: [AuthorizeController, WellKnownController],
   providers: [AuthorizeService],
   exports: [AuthorizeService],
 })