@hed-hog/core 0.0.398 → 0.0.400

package/src/authorize/authorize.service.ts

@@ -7,10 +7,15 @@ import {
   Inject,
   Injectable,
   Logger,
+  UnauthorizedException,
   forwardRef,
 } from '@nestjs/common';
 import { timingSafeEqual } from 'crypto';
 import { AuthService } from '../auth/auth.service';
+import { SessionService } from '../session/session.service';
+import { TokenService } from '../token/token.service';
+import { OAuthError } from './authorize.errors';
+import { MCP_SCOPE, OAuthMetadataService } from './oauth-metadata.service';
 import { SecurityService } from '../security/security.service';
 
 /**
@@ -38,15 +43,26 @@ export class AuthorizeService {
     private readonly security: SecurityService,
     @Inject(forwardRef(() => AuthService))
     private readonly auth: AuthService,
+    @Inject(forwardRef(() => SessionService))
+    private readonly session: SessionService,
+    @Inject(forwardRef(() => TokenService))
+    private readonly token: TokenService,
+    @Inject(forwardRef(() => OAuthMetadataService))
+    private readonly metadata: OAuthMetadataService,
   ) {}
 
+
+
   private async getClient(clientId: string) {
     const client = await this.prisma.oauth_app_client.findUnique({
       where: { client_id: clientId },
     });
 
     if (!client || !client.enabled) {
-      throw new BadRequestException('Aplicativo desconhecido ou desabilitado.');
+      // NAO redirecionavel: sem client valido nao ha redirect_uri de confianca
+      // para onde mandar o erro (RFC 6749 4.1.2.1).
+      this.logger.warn(`[AuthorizeService] client desconhecido ou desabilitado: ${clientId}`);
+      throw new OAuthError('invalid_client', 'Aplicativo desconhecido ou desabilitado.');
     }
 
     return client;
@@ -57,26 +73,102 @@ export class AuthorizeService {
    * normalizar/parsear abriria espaço para bypass (barra final, case do host,
    * userinfo, `origin` valendo "null" em esquemas não-http).
    */
-  private assertRedirectUri(client: { redirect_uris: string }, redirectUri: string) {
+  private assertRedirectUri(
+    client: { redirect_uris: string; client_id?: string },
+    redirectUri: string,
+  ) {
     const allowed = client.redirect_uris
       .split('\n')
       .map((uri) => uri.trim())
       .filter(Boolean);
 
     if (!allowed.includes(redirectUri)) {
-      throw new BadRequestException('redirect_uri não registrado para este aplicativo.');
+      // O valor rejeitado vai para o log de proposito: e por ele que se descobre
+      // o callback real de um cliente novo (o do Claude, por exemplo) sem ter que
+      // adivinhar. Nao e segredo — quem mandou ja o conhece.
+      this.logger.warn(
+        `[AuthorizeService] redirect_uri recusado client=${(client as any).client_id ?? '?'} uri=${redirectUri}`,
+      );
+      throw new OAuthError(
+        'invalid_request',
+        'redirect_uri não registrado para este aplicativo.',
+      );
     }
   }
 
-  private assertScope(client: { scopes: string }, scope: string) {
+  /**
+   * Devolve o escopo efetivo. `scope` ausente assume o que o client tem
+   * registrado — um cliente OAuth padrao pode simplesmente nao mandar o
+   * parametro, e recusa-lo seria recusar o fluxo inteiro por nada.
+   */
+  private assertScope(client: { scopes: string }, scope?: string): string {
     const granted = new Set(client.scopes.split(/[\s,]+/).filter(Boolean));
-    const requested = scope.split(/[\s,]+/).filter(Boolean);
+    const requested = (scope ?? '').split(/[\s,]+/).filter(Boolean);
 
     if (requested.length === 0) {
-      throw new BadRequestException('scope é obrigatório.');
+      return [...granted].join(' ');
     }
     if (!requested.every((s) => granted.has(s))) {
-      throw new BadRequestException('scope não autorizado para este aplicativo.');
+      throw new OAuthError(
+        'invalid_scope',
+        'scope não autorizado para este aplicativo.',
+        true,
+      );
+    }
+    return requested.join(' ');
+  }
+
+  /**
+   * `resource` (RFC 8707) é uma allowlist de um item só: o /mcp deste servidor.
+   * Igualdade exata — o middleware de compatibilidade do main.ts faz `/api/mcp`
+   * responder no mesmo lugar, e comparar por prefixo deixaria nascer um token com
+   * audiência paralela que o TokenService nunca reconheceria.
+   *
+   * E ele é OBRIGATÓRIO quando a concessão inclui o escopo `mcp`. Sem essa regra
+   * o confinamento seria opt-in pela parte que ele restringe: bastava o cliente
+   * omitir o parâmetro para receber um token sem `aud` — válido na API REST
+   * inteira, com o TTL longo de login e renovável pelo /auth/refresh. Um cliente
+   * de MCP nunca deve conseguir uma sessão de propósito geral.
+   */
+  private async assertResource(
+    scope: string,
+    resource?: string,
+  ): Promise<string | null> {
+    const confinedToMcp = scope
+      .split(/[\s,]+/)
+      .filter(Boolean)
+      .includes(MCP_SCOPE);
+
+    if (!resource) {
+      if (confinedToMcp) {
+        throw new OAuthError(
+          'invalid_target',
+          `resource é obrigatório para o escopo '${MCP_SCOPE}'.`,
+          true,
+        );
+      }
+      return null;
+    }
+
+    const mcpResource = await this.metadata.getMcpResource();
+    if (resource !== mcpResource) {
+      throw new OAuthError(
+        'invalid_target',
+        'resource não reconhecido por este servidor.',
+        true,
+      );
+    }
+    return mcpResource;
+  }
+
+  /** RFC 6749: só `code`. Ausente, assume `code` — nenhum client atual manda. */
+  private assertResponseType(responseType?: string) {
+    if (responseType && responseType !== 'code') {
+      throw new OAuthError(
+        'unsupported_response_type',
+        'Apenas response_type=code é suportado.',
+        true,
+      );
     }
   }
 
@@ -84,18 +176,30 @@ export class AuthorizeService {
   async getAuthorizationInfo(params: {
     clientId: string;
     redirectUri: string;
-    scope: string;
+    scope?: string;
     codeChallenge: string;
     codeChallengeMethod: string;
+    responseType?: string;
+    resource?: string;
   }) {
+    // A ordem importa: primeiro o que NAO pode redirecionar (client, redirect),
+    // so depois o que pode. Invertida, um erro de escopo tentaria redirecionar
+    // para um redirect_uri ainda nao validado.
     const client = await this.getClient(params.clientId);
     this.assertRedirectUri(client, params.redirectUri);
-    this.assertScope(client, params.scope);
+
+    this.assertResponseType(params.responseType);
+    const scope = this.assertScope(client, params.scope);
     this.assertPkce(params.codeChallenge, params.codeChallengeMethod);
+    await this.assertResource(scope, params.resource);
 
     return {
       clientName: client.name,
-      scopes: params.scope.split(/[\s,]+/).filter(Boolean),
+      scopes: scope.split(/[\s,]+/).filter(Boolean),
+      // A tela precisa devolver `iss` no redirect (RFC 9207), e anunciamos
+      // `authorization_response_iss_parameter_supported`. Mandar daqui evita mais
+      // uma variavel de ambiente no admin e garante que os dois concordem.
+      issuer: await this.metadata.getIssuer(),
     };
   }
 
@@ -105,7 +209,11 @@ export class AuthorizeService {
    */
   private assertPkce(codeChallenge: string, method: string) {
     if (method !== 'S256') {
-      throw new BadRequestException('code_challenge_method deve ser S256.');
+      throw new OAuthError(
+        'invalid_request',
+        'code_challenge_method deve ser S256.',
+        true,
+      );
     }
     if (
       !codeChallenge ||
@@ -113,7 +221,7 @@ export class AuthorizeService {
       codeChallenge.length > 128 ||
       !/^[A-Za-z0-9\-._~]+$/.test(codeChallenge)
     ) {
-      throw new BadRequestException('code_challenge inválido.');
+      throw new OAuthError('invalid_request', 'code_challenge inválido.', true);
     }
   }
 
@@ -122,14 +230,18 @@ export class AuthorizeService {
     userId: number;
     clientId: string;
     redirectUri: string;
-    scope: string;
+    scope?: string;
     codeChallenge: string;
     codeChallengeMethod: string;
+    responseType?: string;
+    resource?: string;
   }): Promise<string> {
     const client = await this.getClient(params.clientId);
     this.assertRedirectUri(client, params.redirectUri);
-    this.assertScope(client, params.scope);
+    this.assertResponseType(params.responseType);
+    const scope = this.assertScope(client, params.scope);
     this.assertPkce(params.codeChallenge, params.codeChallengeMethod);
+    const resource = await this.assertResource(scope, params.resource);
 
     const code = this.security.randomOpaque(32);
     const codeHash = this.security.hashSha256(code);
@@ -141,10 +253,13 @@ export class AuthorizeService {
         client_id: params.clientId,
         user_id: params.userId,
         redirect_uri: params.redirectUri,
-        scope: params.scope,
+        scope,
         code_challenge: params.codeChallenge,
         code_challenge_method: 'S256',
         expires_at: expiresAt,
+        // Guardado para a troca do code exigir o MESMO recurso. Sem isso um
+        // cliente autorizaria para um recurso e pegaria token para outro.
+        resource,
       },
     });
 
@@ -165,6 +280,7 @@ export class AuthorizeService {
     codeVerifier: string;
     clientId: string;
     redirectUri: string;
+    resource?: string;
     locale: string;
     ipAddress: string;
     userAgent: string;
@@ -179,13 +295,16 @@ export class AuthorizeService {
     const client = await this.getClient(params.clientId);
 
     if (client.client_type !== 'public') {
-      throw new BadRequestException('Fluxo indisponível para este aplicativo.');
+      throw new OAuthError(
+        'unauthorized_client',
+        'Fluxo indisponível para este aplicativo.',
+      );
     }
 
     const codeHash = this.security.hashSha256(params.code);
 
     const rows = await this.prisma.$queryRaw<
-      Array<{ user_id: number; code_challenge: string; scope: string }>
+      Array<{ user_id: number; code_challenge: string; scope: string; resource: string | null }>
     >(
       Prisma.sql`
         UPDATE oauth_authorization_code
@@ -195,13 +314,14 @@ export class AuthorizeService {
           AND redirect_uri = ${params.redirectUri}
           AND expires_at > NOW()
           AND consumed_at IS NULL
-        RETURNING user_id, code_challenge, scope
+        RETURNING user_id, code_challenge, scope, resource
       `,
     );
 
     const row = rows[0];
     if (!row) {
-      throw new BadRequestException(
+      throw new OAuthError(
+        'invalid_grant',
         'Código inválido, expirado ou já utilizado. Refaça a autorização.',
       );
     }
@@ -211,27 +331,193 @@ export class AuthorizeService {
       this.logger.warn(
         `[AuthorizeService] PKCE falhou client=${params.clientId} userId=${row.user_id}`,
       );
-      throw new BadRequestException('code_verifier inválido.');
+      throw new OAuthError('invalid_grant', 'code_verifier inválido.');
     }
 
+    // O recurso pedido agora tem que ser o mesmo pedido na autorizacao. Divergir
+    // aqui seria autorizar para um recurso e receber token para outro.
+    if ((params.resource ?? null) !== (row.resource ?? null)) {
+      throw new OAuthError(
+        'invalid_target',
+        'resource não confere com o da autorização.',
+      );
+    }
+
+    const oauth = row.resource
+      ? {
+          audience: row.resource,
+          scope: row.scope,
+          clientId: params.clientId,
+          issuer: await this.metadata.getIssuer(),
+          ttlMinutes: SessionService.CONNECTOR_SESSION_TTL_MINUTES,
+        }
+      : undefined;
+
     const { accessToken, refreshToken } = await this.auth.getAuthenticationPayload(
       params.locale,
       row.user_id,
       params.ipAddress,
       params.userAgent,
       params.browserId,
+      oauth,
     );
 
+    return this.buildTokenResponse(accessToken, refreshToken, row.scope);
+  }
+
+  /**
+   * Renovacao do cliente OAuth externo.
+   *
+   * Existe separado do POST /auth/refresh porque aquele devolve um token SEM
+   * `aud` — e por isso mesmo recusa sessao de conector. Aqui o `aud` e reaplicado
+   * a partir da propria sessao, que e a unica coisa que sobrevive a rotacao do
+   * refresh token (que e opaco).
+   */
+  async exchangeRefreshToken(params: {
+    refreshToken: string;
+    clientId: string;
+    resource?: string;
+    locale: string;
+    ipAddress: string;
+    userAgent: string;
+    browserId?: string | null;
+  }) {
+    const client = await this.getClient(params.clientId);
+
+    if (client.client_type !== 'public') {
+      throw new OAuthError(
+        'unauthorized_client',
+        'Fluxo indisponível para este aplicativo.',
+      );
+    }
+
+    // TUDO o que pode recusar acontece ANTES de girar.
+    //
+    // `session.refresh()` commita o compare-and-swap na hora: o token que o
+    // cliente tem passa a valer por mais 30s (a janela de graca) e o substituto
+    // so existe se a chamada chegar ao fim. Validar depois dela transformava
+    // qualquer recusa — client errado, resource divergente — na destruicao da
+    // sessao do cliente, em vez da negacao de um pedido.
+    const existing = await this.session.peekByRefreshToken(params.refreshToken);
+
+    if (!existing || existing.revoked_at !== null || existing.expires_at <= new Date()) {
+      throw new OAuthError(
+        'invalid_grant',
+        'refresh_token inválido, expirado ou revogado.',
+      );
+    }
+
+    // A sessao tem que ser deste client. Sem esta checagem, o refresh token de um
+    // cliente valeria apresentado por outro.
+    if (existing.oauth_client_id && existing.oauth_client_id !== params.clientId) {
+      throw new OAuthError(
+        'invalid_grant',
+        'refresh_token não pertence a este aplicativo.',
+      );
+    }
+
+    const audience = existing.audience ?? null;
+    if ((params.resource ?? null) !== audience) {
+      throw new OAuthError(
+        'invalid_target',
+        'resource não confere com o da sessão.',
+      );
+    }
+
+    // O escopo sai do que o client tem REGISTRADO, nunca de um literal. Fixar
+    // 'mcp' aqui promovia a cliente de MCP qualquer client que chegasse a este
+    // endpoint — inclusive os que so tem 'profile' ou 'vaults'.
+    const scope = this.assertScope(client);
+
+    // Uma sessao de recurso so pode ser renovada por um client que ainda tenha o
+    // escopo correspondente. Se o registro do client mudou no meio do caminho, a
+    // renovacao para aqui em vez de emitir um token que o McpAuthGuard recusaria.
+    if (audience && !scope.split(/[\s,]+/).filter(Boolean).includes(MCP_SCOPE)) {
+      throw new OAuthError(
+        'invalid_scope',
+        `Este aplicativo não tem mais o escopo '${MCP_SCOPE}'.`,
+      );
+    }
+
+    let session: any;
+    let token: string;
+    try {
+      ({ session, token } = await this.session.refresh(
+        params.locale,
+        params.refreshToken,
+        params.ipAddress,
+        params.userAgent,
+        params.browserId ?? null,
+      ));
+    } catch (error) {
+      // So o que o SessionService classifica como credencial invalida vira
+      // invalid_grant. Erro de infraestrutura (timeout, pool esgotado) NAO pode:
+      // pelo RFC 6749 5.2 esse codigo manda o cliente descartar o refresh token,
+      // entao um soluco de banco desconectaria todo mundo de forma permanente.
+      if (error instanceof UnauthorizedException) {
+        throw new OAuthError(
+          'invalid_grant',
+          'refresh_token inválido, expirado ou revogado.',
+        );
+      }
+      throw error;
+    }
+
+    const payload = audience
+      ? {
+          sub: session.user_id,
+          sessionId: session.id,
+          aud: audience,
+          iss: await this.metadata.getIssuer(),
+          scope,
+          cid: params.clientId,
+        }
+      : { sub: session.user_id, sessionId: session.id };
+
+    const accessToken = await this.token.createAccessToken(payload);
+
+    return this.buildTokenResponse(accessToken, token, scope);
+  }
+
+  /**
+   * `expires_in` sai do `exp` do proprio JWT recem-assinado, e nao da setting: o
+   * JwtModule le `access-token-expiration-minutes` uma UNICA vez, no boot, entao a
+   * setting e o token podem divergir ate o proximo deploy. O token e a verdade.
+   *
+   * A resposta traz snake_case e camelCase ao mesmo tempo. O RFC 6749 5.1 permite
+   * membros extras, e os cinco clientes ja registrados leem camelCase — passar so
+   * a snake_case quebraria todos de uma vez.
+   */
+  private buildTokenResponse(accessToken: string, refreshToken: string, scope: string) {
+    const expiresIn = this.expiresInFromJwt(accessToken);
+
     return {
+      access_token: accessToken,
       accessToken,
+      refresh_token: refreshToken,
       refreshToken,
+      token_type: 'Bearer',
       tokenType: 'Bearer',
-      // Informativo para o cliente agendar refresh; a verdade é o exp do JWT.
-      expiresIn: 3600,
-      scope: row.scope,
+      expires_in: expiresIn,
+      expiresIn,
+      scope,
     };
   }
 
+  private expiresInFromJwt(accessToken: string): number {
+    try {
+      const claims = JSON.parse(
+        Buffer.from(accessToken.split('.')[1], 'base64url').toString('utf8'),
+      );
+      const seconds = Number(claims?.exp) - Math.floor(Date.now() / 1000);
+      return seconds > 0 ? seconds : 0;
+    } catch {
+      // Token sem exp legivel nao deve derrubar a resposta; o cliente reage ao
+      // 401 de qualquer forma.
+      return 0;
+    }
+  }
+
   /** base64url(sha256(verifier)) === challenge, em tempo constante. */
   private verifyPkce(codeVerifier: string, codeChallenge: string): boolean {
     if (!codeVerifier || codeVerifier.length < 43 || codeVerifier.length > 128) {

package/src/authorize/dto/authorize-info.dto.ts

@@ -1,4 +1,4 @@
-import { IsNotEmpty, IsString } from 'class-validator';
+import { IsNotEmpty, IsOptional, IsString } from 'class-validator';
 
 export class AuthorizeInfoDTO {
   @IsString()
@@ -9,9 +9,10 @@ export class AuthorizeInfoDTO {
   @IsNotEmpty()
   redirect_uri: string;
 
+  /** Ausente, assume os escopos registrados do client. */
+  @IsOptional()
   @IsString()
-  @IsNotEmpty()
-  scope: string;
+  scope?: string;
 
   @IsString()
   @IsNotEmpty()
@@ -20,4 +21,21 @@ export class AuthorizeInfoDTO {
   @IsString()
   @IsNotEmpty()
   code_challenge_method: string;
+
+  /**
+   * Opcionais porque os cinco clientes ja registrados nao os mandam. Quando
+   * ausentes, o comportamento e byte a byte o de hoje; quando presentes e
+   * invalidos, a requisicao e recusada.
+   */
+  @IsOptional()
+  @IsString()
+  response_type?: string;
+
+  @IsOptional()
+  @IsString()
+  resource?: string;
+
+  @IsOptional()
+  @IsString()
+  state?: string;
 }

package/src/authorize/dto/consent.dto.ts

@@ -1,4 +1,4 @@
-import { IsNotEmpty, IsString } from 'class-validator';
+import { IsNotEmpty, IsOptional, IsString } from 'class-validator';
 
 export class ConsentDTO {
   @IsString()
@@ -9,9 +9,10 @@ export class ConsentDTO {
   @IsNotEmpty()
   redirect_uri: string;
 
+  /** Ausente, assume os escopos registrados do client. */
+  @IsOptional()
   @IsString()
-  @IsNotEmpty()
-  scope: string;
+  scope?: string;
 
   @IsString()
   @IsNotEmpty()
@@ -20,4 +21,21 @@ export class ConsentDTO {
   @IsString()
   @IsNotEmpty()
   code_challenge_method: string;
+
+  /**
+   * Opcionais porque os cinco clientes ja registrados nao os mandam. Quando
+   * ausentes, o comportamento e byte a byte o de hoje; quando presentes e
+   * invalidos, a requisicao e recusada.
+   */
+  @IsOptional()
+  @IsString()
+  response_type?: string;
+
+  @IsOptional()
+  @IsString()
+  resource?: string;
+
+  @IsOptional()
+  @IsString()
+  state?: string;
 }

package/src/authorize/dto/token.dto.ts

@@ -1,14 +1,22 @@
-import { IsIn, IsNotEmpty, IsString } from 'class-validator';
+import { IsIn, IsNotEmpty, IsOptional, IsString, ValidateIf } from 'class-validator';
 
+/**
+ * Os campos obrigatórios dependem do grant. `authorization_code` continua
+ * exigindo exatamente o que exigia; `refresh_token` só existe para o cliente
+ * OAuth externo renovar sem passar pelo `/auth/refresh` — que devolve token sem
+ * audiência e por isso recusa sessão de conector.
+ */
 export class TokenDTO {
   @IsString()
-  @IsIn(['authorization_code'])
+  @IsIn(['authorization_code', 'refresh_token'])
   grant_type: string;
 
+  @ValidateIf((o) => o.grant_type !== 'refresh_token')
   @IsString()
   @IsNotEmpty()
   code: string;
 
+  @ValidateIf((o) => o.grant_type !== 'refresh_token')
   @IsString()
   @IsNotEmpty()
   code_verifier: string;
@@ -17,7 +25,21 @@ export class TokenDTO {
   @IsNotEmpty()
   client_id: string;
 
+  @ValidateIf((o) => o.grant_type !== 'refresh_token')
   @IsString()
   @IsNotEmpty()
   redirect_uri: string;
+
+  @ValidateIf((o) => o.grant_type === 'refresh_token')
+  @IsString()
+  @IsNotEmpty()
+  refresh_token: string;
+
+  /**
+   * RFC 8707. Opcional: sem ele o token sai sem `aud` e o comportamento é o de
+   * hoje — que é o que os cinco clientes já registrados esperam.
+   */
+  @IsOptional()
+  @IsString()
+  resource?: string;
 }

package/src/authorize/oauth-exception.filter.ts

@@ -0,0 +1,58 @@
+import {
+  ArgumentsHost,
+  Catch,
+  ExceptionFilter,
+  HttpException,
+} from '@nestjs/common';
+import { Response } from 'express';
+import { OAuthError } from './authorize.errors';
+
+/**
+ * Traduz o que sai dos endpoints OAuth para o formato do RFC 6749 §5.2:
+ * `{ error, error_description }`, sempre `no-store`.
+ *
+ * Existe porque o `HttpExceptionFilter` global quase serve, mas não nos dois
+ * casos que importam: ele acrescenta `statusCode`/`timestamp`/`path` ao corpo, e
+ * uma falha do `ValidationPipe` sai como `{ message: { campo: [...] } }`, que não
+ * é um erro OAuth e nenhum cliente sabe ler.
+ *
+ * O campo `message` é preservado de propósito — os cinco clientes já registrados
+ * leem ele nas respostas de erro de hoje.
+ */
+@Catch(HttpException)
+export class OAuthExceptionFilter implements ExceptionFilter {
+  catch(exception: HttpException, host: ArgumentsHost): void {
+    const response = host.switchToHttp().getResponse<Response>();
+    const status = exception.getStatus();
+    const body = exception.getResponse() as any;
+
+    response.setHeader('Cache-Control', 'no-store');
+    response.setHeader('Pragma', 'no-cache');
+
+    if (exception instanceof OAuthError) {
+      response.status(status).json({
+        error: body.error,
+        error_description: body.error_description,
+        ...(body.redirectable ? { redirectable: true } : {}),
+        ...(body.issuer ? { issuer: body.issuer } : {}),
+        message: body.message,
+      });
+      return;
+    }
+
+    // Falha de validação de DTO: vira invalid_request, com a mensagem original
+    // preservada para quem estiver depurando.
+    const description =
+      typeof body === 'string'
+        ? body
+        : typeof body?.message === 'string'
+          ? body.message
+          : JSON.stringify(body?.message ?? 'Invalid request.');
+
+    response.status(status).json({
+      error: status === 400 ? 'invalid_request' : 'server_error',
+      error_description: description,
+      message: body?.message ?? description,
+    });
+  }
+}