@hed-hog/core 0.0.398 → 0.0.400

package/src/file/remote-fetch.util.ts

@@ -0,0 +1,330 @@
+import { BadRequestException } from '@nestjs/common';
+import { Agent as HttpAgent } from 'http';
+import { Agent as HttpsAgent } from 'https';
+import { isIP } from 'net';
+import { lookup as dnsLookup } from 'dns';
+import axios from 'axios';
+
+/**
+ * Download de URL informada por quem chama a tool (`fileUrl`).
+ *
+ * É a única superfície do sistema em que um endereço escolhido pelo usuário vira uma
+ * requisição saindo de dentro do cluster, então a guarda de SSRF mora aqui. O repositório
+ * não tinha nada equivalente: a única util de URL existente (`assertHttpUrl`, em
+ * `integration-profile/testers/http-probe.ts`) **libera faixas privadas de propósito**,
+ * porque serve para Evolution e k8s auto-hospedados — usá-la aqui seria o oposto do que
+ * se precisa.
+ *
+ * O ponto não óbvio é *quando* validar o IP. Resolver o nome, aprovar e só então deixar o
+ * axios conectar abre uma janela: entre a checagem e a conexão o DNS pode responder outra
+ * coisa (rebinding), e quem conecta é o agente, não nós. Por isso a validação é instalada
+ * como o `lookup` do agente — ela roda no momento em que o socket é aberto, sobre o mesmo
+ * endereço que será usado. Cada redirect repete tudo, porque o destino muda.
+ */
+
+const PRIVATE_IPV4_RULES: Array<{ cidr: string; reason: string }> = [
+  { cidr: '0.0.0.0/8', reason: 'this-network' },
+  { cidr: '10.0.0.0/8', reason: 'private' },
+  { cidr: '100.64.0.0/10', reason: 'carrier-grade NAT' },
+  { cidr: '127.0.0.0/8', reason: 'loopback' },
+  { cidr: '169.254.0.0/16', reason: 'link-local / cloud metadata' },
+  { cidr: '172.16.0.0/12', reason: 'private' },
+  { cidr: '192.0.0.0/24', reason: 'IETF protocol assignments' },
+  { cidr: '192.0.2.0/24', reason: 'documentation' },
+  { cidr: '192.168.0.0/16', reason: 'private' },
+  { cidr: '198.18.0.0/15', reason: 'benchmarking' },
+  { cidr: '198.51.100.0/24', reason: 'documentation' },
+  { cidr: '203.0.113.0/24', reason: 'documentation' },
+  { cidr: '224.0.0.0/4', reason: 'multicast' },
+  { cidr: '240.0.0.0/4', reason: 'reserved' },
+];
+
+const ipv4ToInt = (ip: string): number =>
+  ip.split('.').reduce((acc, part) => (acc << 8) + Number(part), 0) >>> 0;
+
+const matchesCidr = (ip: string, cidr: string): boolean => {
+  const [range, bitsRaw] = cidr.split('/');
+  const bits = Number(bitsRaw);
+  const mask = bits === 0 ? 0 : (0xffffffff << (32 - bits)) >>> 0;
+  return (ipv4ToInt(ip) & mask) === (ipv4ToInt(range) & mask);
+};
+
+/**
+ * Motivo da recusa, ou `null` quando o endereço é público.
+ *
+ * IPv6 mapeado (`::ffff:169.254.169.254`) é desempacotado antes do cotejo: sem isso, o
+ * endpoint de metadados volta a ser alcançável pela notação de seis grupos.
+ */
+export function describeBlockedAddress(address: string): string | null {
+  const value = String(address || '').trim().toLowerCase();
+
+  if (!value) {
+    return 'empty address';
+  }
+
+  const mapped = value.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/);
+  const candidate = mapped ? mapped[1] : value;
+  const version = isIP(candidate);
+
+  if (version === 4) {
+    const rule = PRIVATE_IPV4_RULES.find((entry) => matchesCidr(candidate, entry.cidr));
+    return rule ? `${rule.reason} address (${candidate})` : null;
+  }
+
+  if (version === 6) {
+    if (candidate === '::' || candidate === '::1') {
+      return `loopback address (${candidate})`;
+    }
+
+    // fc00::/7 (unique local) e fe80::/10 (link-local, onde vive fe80::a9fe:a9fe).
+    if (/^f[cd]/.test(candidate)) {
+      return `unique local address (${candidate})`;
+    }
+
+    if (/^fe[89ab]/.test(candidate)) {
+      return `link-local address (${candidate})`;
+    }
+
+    if (/^ff/.test(candidate)) {
+      return `multicast address (${candidate})`;
+    }
+
+    return null;
+  }
+
+  return `unresolvable address (${address})`;
+}
+
+/**
+ * `lookup` compatível com o do Node que recusa antes de devolver o endereço ao agente.
+ *
+ * O agente chama isto para cada conexão, então é aqui que a decisão vale — e não numa
+ * checagem prévia que o DNS poderia contradizer depois.
+ */
+const guardedLookup = (
+  hostname: string,
+  options: any,
+  callback: (err: NodeJS.ErrnoException | null, address?: any, family?: number) => void,
+): void => {
+  const done = typeof options === 'function' ? options : callback;
+  const opts = typeof options === 'function' ? {} : options;
+
+  dnsLookup(hostname, { ...opts, all: true } as any, (err, addresses: any) => {
+    if (err) {
+      done(err);
+      return;
+    }
+
+    const list = Array.isArray(addresses) ? addresses : [addresses];
+
+    if (list.length === 0) {
+      done(Object.assign(new Error(`Host did not resolve: ${hostname}`), { code: 'ENOTFOUND' }));
+      return;
+    }
+
+    // Basta um endereço proibido para recusar o host inteiro: aceitar os "bons" deixaria
+    // o resultado na mão de qual entrada o resolvedor devolve primeiro.
+    for (const entry of list) {
+      const blocked = describeBlockedAddress(entry.address);
+      if (blocked) {
+        done(
+          Object.assign(new Error(`Blocked ${blocked} for host ${hostname}`), {
+            code: 'EBLOCKED',
+          }),
+        );
+        return;
+      }
+    }
+
+    const first = list[0];
+
+    if (opts?.all) {
+      done(null, list as any);
+      return;
+    }
+
+    done(null, first.address, first.family);
+  });
+};
+
+export interface RemoteFetchOptions {
+  /** Teto de bytes; o download aborta assim que o passa, sem bufferizar o resto. */
+  maxBytes: number;
+  /** Hosts liberados. Vazio (o default) = qualquer host público. */
+  allowedHosts?: string[];
+  timeoutMs?: number;
+  maxRedirects?: number;
+}
+
+export interface RemoteFetchResult {
+  buffer: Buffer;
+  /** `Content-Type` da resposta, sem parâmetros. Informativo: quem manda é o conteúdo. */
+  contentType: string | null;
+  /** Host de onde o conteúdo veio de fato, depois de seguidos os redirects. */
+  finalHost: string;
+  finalUrl: string;
+}
+
+const DEFAULT_TIMEOUT_MS = 15000;
+const DEFAULT_MAX_REDIRECTS = 3;
+
+/** Valida esquema, credenciais e allowlist. Separada para poder ser testada sozinha. */
+export function assertFetchableUrl(raw: string, allowedHosts?: string[]): URL {
+  let url: URL;
+
+  try {
+    url = new URL(String(raw || '').trim());
+  } catch {
+    throw new BadRequestException(`fileUrl is not a valid URL`);
+  }
+
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    throw new BadRequestException(
+      `fileUrl must use http or https, got ${url.protocol.replace(':', '') || 'none'}`,
+    );
+  }
+
+  // Credencial na URL viraria header de autenticação para um destino escolhido por quem
+  // chama — e apareceria no log de auditoria junto com o resto da entrada.
+  if (url.username || url.password) {
+    throw new BadRequestException(`fileUrl must not carry credentials`);
+  }
+
+  const allow = (allowedHosts || []).map((h) => h.trim().toLowerCase()).filter(Boolean);
+
+  if (allow.length > 0) {
+    const host = url.hostname.toLowerCase();
+    const permitted = allow.some(
+      (entry) => host === entry || host.endsWith(`.${entry}`),
+    );
+
+    if (!permitted) {
+      throw new BadRequestException(
+        `fileUrl host is not allowed: ${host}. Allowed hosts come from the mcp-file-url-allowed-hosts setting.`,
+      );
+    }
+  }
+
+  return url;
+}
+
+/**
+ * Baixa a URL para memória, recusando destino privado e conteúdo acima do teto.
+ *
+ * Os redirects são seguidos à mão (`maxRedirects: 0` no axios) porque cada salto é um
+ * destino novo que precisa passar pela mesma validação — deixar o axios seguir sozinho
+ * entregaria o segundo salto sem conferência, que é justamente como se contorna uma
+ * allowlist que só olha a URL inicial.
+ */
+export async function fetchRemoteFile(
+  rawUrl: string,
+  options: RemoteFetchOptions,
+): Promise<RemoteFetchResult> {
+  const maxRedirects = options.maxRedirects ?? DEFAULT_MAX_REDIRECTS;
+  const timeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+
+  let current = assertFetchableUrl(rawUrl, options.allowedHosts);
+
+  for (let hop = 0; hop <= maxRedirects; hop += 1) {
+    const isHttps = current.protocol === 'https:';
+    const AgentCtor = isHttps ? HttpsAgent : HttpAgent;
+    const agent = new AgentCtor({ lookup: guardedLookup as any });
+
+    let response: any;
+
+    try {
+      response = await axios.get(current.toString(), {
+        responseType: 'stream',
+        timeout,
+        maxRedirects: 0,
+        // Teto redundante com o contador abaixo, mas ele corta antes de o axios montar
+        // qualquer buffer quando o servidor declara o tamanho.
+        maxContentLength: options.maxBytes,
+        maxBodyLength: options.maxBytes,
+        decompress: true,
+        validateStatus: (status: number) => status < 400,
+        ...(isHttps ? { httpsAgent: agent } : { httpAgent: agent }),
+      });
+    } catch (error: any) {
+      if (error?.code === 'EBLOCKED') {
+        throw new BadRequestException(`fileUrl rejected: ${error.message}`);
+      }
+
+      if (error?.response?.status) {
+        throw new BadRequestException(
+          `fileUrl responded with HTTP ${error.response.status}`,
+        );
+      }
+
+      throw new BadRequestException(`fileUrl download failed: ${error?.message || error}`);
+    }
+
+    const status = Number(response.status);
+
+    if (status >= 300 && status < 400) {
+      const location = response.headers?.location;
+      response.data?.destroy?.();
+
+      if (!location) {
+        throw new BadRequestException(`fileUrl redirected without a location header`);
+      }
+
+      if (hop === maxRedirects) {
+        throw new BadRequestException(
+          `fileUrl exceeded the redirect limit of ${maxRedirects}`,
+        );
+      }
+
+      current = assertFetchableUrl(
+        new URL(location, current).toString(),
+        options.allowedHosts,
+      );
+      continue;
+    }
+
+    const buffer = await readStreamWithLimit(response.data, options.maxBytes);
+
+    return {
+      buffer,
+      contentType: String(response.headers?.['content-type'] || '').split(';')[0] || null,
+      finalHost: current.hostname,
+      finalUrl: current.toString(),
+    };
+  }
+
+  throw new BadRequestException(`fileUrl exceeded the redirect limit of ${maxRedirects}`);
+}
+
+/**
+ * Acumula o stream até o teto e aborta na primeira parte que o ultrapassa.
+ *
+ * `maxContentLength` do axios só vale quando o servidor declara `Content-Length`; sem o
+ * contador, uma resposta sem tamanho declarado encheria a memória do pod.
+ */
+function readStreamWithLimit(stream: any, maxBytes: number): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    let total = 0;
+
+    stream.on('data', (chunk: Buffer) => {
+      total += chunk.length;
+
+      if (total > maxBytes) {
+        stream.destroy();
+        reject(
+          new BadRequestException(
+            `fileUrl content exceeds the maximum of ${maxBytes} bytes`,
+          ),
+        );
+        return;
+      }
+
+      chunks.push(Buffer.from(chunk));
+    });
+
+    stream.on('end', () => resolve(Buffer.concat(chunks)));
+    stream.on('error', (error: any) =>
+      reject(new BadRequestException(`fileUrl download failed: ${error?.message || error}`)),
+    );
+  });
+}

package/src/impersonation/dto/start-impersonation.dto.ts

@@ -1,8 +1,11 @@
 import { IsIn, IsOptional, IsString, MaxLength } from 'class-validator';
 
 export class StartImpersonationDTO {
-  /** Chave do app de destino em `app-urls`. */
-  @IsIn(['admin', 'class', 'partners'])
+  /**
+   * Chave do app de destino em `app-urls`. Espelha
+   * `ImpersonationService.REDEEMABLE_APPS`: app novo entra nos dois lugares.
+   */
+  @IsIn(['admin', 'class', 'partners', 'training'])
   app: string;
 
   /** Justificativa livre do operador; vai para a trilha de auditoria. */

package/src/impersonation/impersonation.service.spec.ts

@@ -188,10 +188,23 @@ describe('ImpersonationService', () => {
 
     it('recusa app sem tela de resgate', async () => {
       await expect(
-        service.start(startParams({ app: 'training' }) as never),
+        service.start(startParams({ app: 'site' }) as never),
       ).rejects.toThrow(BadRequestException);
     });
 
+    it('aceita o training, que tem tela de resgate própria', async () => {
+      deps.setting.getSettingValues.mockResolvedValue({
+        'app-urls': ['training=https://hcode.training'],
+        'impersonation-session-minutes': 30,
+      } as never);
+
+      await expect(
+        service.start(startParams({ app: 'training' }) as never),
+      ).resolves.toMatchObject({
+        url: expect.stringContaining('https://hcode.training/simulacao#code='),
+      });
+    });
+
     it('recusa app sem URL configurada em app-urls', async () => {
       await expect(
         service.start(startParams({ app: 'partners' }) as never),
@@ -423,5 +436,15 @@ describe('ImpersonationService', () => {
         { key: 'class', url: 'https://class.example.com' },
       ]);
     });
+
+    it('lista o training quando ele está em app-urls', async () => {
+      deps.setting.getSettingValues.mockResolvedValue({
+        'app-urls': ['training=https://hcode.training', 'site=https://hcode.com.br'],
+      } as never);
+
+      await expect(service.listRedeemableApps()).resolves.toEqual([
+        { key: 'training', url: 'https://hcode.training' },
+      ]);
+    });
   });
 });

package/src/impersonation/impersonation.service.ts

@@ -68,7 +68,7 @@ export class ImpersonationService {
   /** Curto: o codigo so precisa sobreviver ao carregamento da aba nova. */
   private readonly codeTtlMs = 60_000;
 
-  /** Caminho da tela de resgate, igual nos tres apps. */
+  /** Caminho da tela de resgate, igual em todos os apps. */
   static readonly REDEEM_PATH = '/simulacao';
 
   /**
@@ -78,10 +78,20 @@ export class ImpersonationService {
   private static readonly BLOCKED_TARGET_ROLES = ['admin', 'admin-impersonation'];
 
   /**
-   * Apps com tela de resgate. `training` tem autenticacao propria e nao usa o
-   * @hed-hog/next-app-provider, entao ficou fora desta fase.
+   * Apps com tela de resgate em `/simulacao`. `training` nao usa o
+   * @hed-hog/next-app-provider — tem AuthProvider proprio —, entao a tela de
+   * resgate, a faixa e a trava de refresh dele sao codigo do proprio app.
+   *
+   * Esta lista e a que alimenta o select do operador; quem valida a entrada do
+   * `start` e o `@IsIn` do StartImpersonationDTO. As duas precisam andar juntas:
+   * so aqui, o app aparece no select e o `start` responde 400.
    */
-  private static readonly REDEEMABLE_APPS = ['admin', 'class', 'partners'];
+  private static readonly REDEEMABLE_APPS = [
+    'admin',
+    'class',
+    'partners',
+    'training',
+  ];
 
   constructor(
     @Inject(forwardRef(() => PrismaService))

package/src/incident/incident.controller.ts

@@ -1,5 +1,6 @@
 import { Role, User } from '@hed-hog/api';
 import { Pagination } from '@hed-hog/api-pagination';
+import { DateRangeQueryDTO } from '../utils/date-range-query.dto';
 import { Controller, Get, Inject, Param, Patch, Query, forwardRef } from '@nestjs/common';
 import { IncidentService, type IncidentSeverity } from './incident.service';
 
@@ -14,11 +15,18 @@ export class IncidentController {
   @Get()
   async list(
     @Pagination() paginationParams,
+    @Query() range: DateRangeQueryDTO,
     @Query('source') source?: string,
     @Query('severity') severity?: IncidentSeverity,
     @Query('status') status?: 'open' | 'resolved' | 'all',
   ) {
-    return this.incidentService.list({ ...paginationParams, source, severity, status });
+    return this.incidentService.list({
+      ...paginationParams,
+      ...range,
+      source,
+      severity,
+      status,
+    });
   }
 
   @Get('summary')

package/src/incident/incident.service.ts

@@ -1,4 +1,5 @@
 import { PageOrderDirection, PaginationService } from '@hed-hog/api-pagination';
+import { dateRangeWhere } from '../utils/date-range';
 import { PrismaService } from '@hed-hog/api-prisma';
 import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
 import { createHash } from 'crypto';
@@ -33,6 +34,8 @@ export interface IncidentListParams {
   source?: string;
   severity?: IncidentSeverity;
   status?: 'open' | 'resolved' | 'all';
+  from?: string;
+  to?: string;
 }
 
 const MAX_MESSAGE_LENGTH = 2000;
@@ -141,6 +144,10 @@ export class IncidentService {
     if (params.source) where.source = params.source;
     if (params.severity) where.severity = params.severity;
 
+    // Recorte pela última ocorrência, que é também a ordenação da tela:
+    // "o que apareceu na semana passada" é a pergunta de quem investiga.
+    Object.assign(where, dateRangeWhere('last_seen_at', params.from, params.to));
+
     // Aberto é o default: a tela existe para mostrar o que precisa de ação.
     if (params.status !== 'all') {
       where.resolved_at = params.status === 'resolved' ? { not: null } : null;

package/src/index.ts

@@ -30,6 +30,9 @@ export * from './leaked-password/leaked-password.service';
 
 export * from './mail-layout/mail-layout.module';
 export * from './mail-layout/mail-layout.service';
+export * from './message-template/message-template.module';
+export * from './message-template/message-template.registry';
+export * from './message-template/message-template.service';
 export * from './mail/mail.module';
 export * from './mail/mail.service';
 
@@ -41,11 +44,18 @@ export * from './integration-profile/integration-credential-crypto.service';
 export * from './integration-profile/testers/integration-tester.types';
 export * from './integration-profile/testers/integration-tester.registry';
 
+export * from './whatsapp-sender/whatsapp-recipients';
 export * from './whatsapp-sender/whatsapp-sender.module';
 export * from './whatsapp-sender/whatsapp-sender.service';
 
 export * from './file/file.module';
 export * from './file/file.service';
+export * from './file/filename-encoding.util';
+export * from './file/file-upload-ticket.service';
+export * from './file/mcp-file-source.service';
+export * from './file/mcp-file-source.schema';
+export * from './file/mimetype-sniff.util';
+export * from './file/remote-fetch.util';
 
 export * from './pdf/pdf.module';
 export * from './pdf/pdf.service';
@@ -122,10 +132,14 @@ export * from './utils/locale-context';
 export * from './utils/geo-ip';
 export * from './utils/user-agent';
 export * from './utils/security-event-vars';
+export * from './utils/abbreviate-name';
+export * from './utils/date-range';
+export * from './utils/date-range-query.dto';
 
 
 // Notification Module
 export * from './notification/dto/create-notification.dto';
+export * from './notification/notification.constants';
 export * from './notification/notification.module';
 export * from './notification/notification.service';
 
@@ -133,6 +147,9 @@ export * from './notification/notification.service';
 export * from './realtime/realtime.module';
 export * from './realtime/realtime.service';
 export * from './realtime/realtime.gateway';
+export * from './realtime/realtime-tick.coalescer';
+export * from './redis/redis-kv.service';
+export * from './redis/redis.module';
 
 // Presence Module
 export * from './presence/presence.module';

package/src/integration-profile/integration-profile.secrets.ts

@@ -69,6 +69,13 @@ export const INTEGRATION_SECRET_KEYS: Record<string, string[]> = {
   // O certificado A1 é a chave privada da empresa: quem tem o PFX + a senha
   // emite nota em nome dela. Os dois DEVEM estar aqui.
   'nfse-national': ['certificate_pfx_base64', 'certificate_password'],
+  // Frete
+  // O token do Melhor Envio compra etiqueta na carteira da conta, não só cota
+  // frete: vale como credencial de pagamento. `refresh_token` vale ainda mais —
+  // ele gera tokens novos indefinidamente —, e o OAuth deles o ROTACIONA a cada
+  // uso, então ele é reescrito no perfil a cada renovação: se não estiver aqui,
+  // cada renovação grava a credencial em texto puro no banco.
+  'melhor-envio': ['access_token', 'client_secret', 'refresh_token'],
 };
 
 /** Chaves sensíveis de um provider (vazio se desconhecido). */

package/src/integration-profile/integration-profile.service.ts

@@ -165,30 +165,18 @@ export class IntegrationProfileService {
     const items = Array.isArray(result.data) ? result.data : [];
     if (items.length > 0) {
       const ids = items.map((p: any) => p.id as number);
-      const usageTables = await this.getExistingUsageTables();
-
-      const counts =
-        usageTables.length === 0
-          ? []
-          : await this.prismaService.$queryRawUnsafe<
-              { id: number; uses_count: bigint }[]
-            >(
-              `
+      const counts = await this.prismaService.$queryRaw<
+        { id: number; uses_count: bigint }[]
+      >`
         SELECT
           ip.id,
           (
-            ${usageTables
-              .map(
-                (table) =>
-                  `COALESCE((SELECT COUNT(*)::int FROM ${table} WHERE integration_profile_id = ip.id), 0)`,
-              )
-              .join(' + ')}
+            COALESCE((SELECT COUNT(*)::int FROM campaign       WHERE integration_profile_id = ip.id), 0) +
+            COALESCE((SELECT COUNT(*)::int FROM webhook_action WHERE integration_profile_id = ip.id), 0)
           ) AS uses_count
         FROM integration_profile ip
-        WHERE ip.id = ANY($1::int[])
-      `,
-              ids,
-            );
+        WHERE ip.id = ANY(${ids}::int[])
+      `;
 
       const countMap = new Map(
         counts.map((r) => [r.id, Number(r.uses_count)]),
@@ -208,51 +196,6 @@ export class IntegrationProfileService {
     return result;
   }
 
-  /**
-   * Tabelas que referenciam um perfil de integração, para o contador `uses_count`.
-   *
-   * Nem toda instalação tem todas: `campaign` vem de uma library de marketing que
-   * pode não estar instalada, enquanto `webhook_action` é do core. O Postgres
-   * valida os nomes de relação ao analisar a query, então citar uma tabela ausente
-   * não devolve zero — derruba o `$queryRaw` inteiro com 42P01 e, com ele, toda a
-   * listagem de perfis (500, sem nenhum perfil visível na tela).
-   */
-  private static readonly USAGE_TABLES = ['campaign', 'webhook_action'];
-
-  /** Cacheado: o conjunto de tabelas só muda com migration, não entre requests. */
-  private existingUsageTables: string[] | null = null;
-
-  private async getExistingUsageTables(): Promise<string[]> {
-    if (this.existingUsageTables) return this.existingUsageTables;
-
-    const rows = await this.prismaService.$queryRaw<{ table_name: string }[]>`
-      SELECT table_name
-      FROM information_schema.tables
-      WHERE table_schema = 'public'
-        AND table_name = ANY(${IntegrationProfileService.USAGE_TABLES}::text[])
-    `;
-
-    const found = new Set(rows.map((r) => r.table_name));
-
-    // Filtrar a constante (em vez de usar o retorno do banco direto) mantém os
-    // nomes interpolados na query restritos a esta lista fixa.
-    this.existingUsageTables = IntegrationProfileService.USAGE_TABLES.filter(
-      (table) => found.has(table),
-    );
-
-    const missing = IntegrationProfileService.USAGE_TABLES.filter(
-      (table) => !found.has(table),
-    );
-
-    if (missing.length > 0) {
-      this.logger.log(
-        `uses_count ignora tabela(s) ausente(s) nesta instalação: ${missing.join(', ')}.`,
-      );
-    }
-
-    return this.existingUsageTables;
-  }
-
   /**
    * Resolve o config do perfil de integração ATIVO para um par tipo/provider — uso
    * server-side por serviços que precisam das credenciais (ex.: InfraScaler do

package/src/integration-profile/integration-profile.utils.spec.ts

@@ -111,6 +111,15 @@ describe('integration-profile.utils', () => {
     it('trata config null', () => {
       expect(getFromAddress(null)).toBe('');
     });
+
+    // Espaco sobrando no perfil virava `Alice < a@b.com>` e o SES recusava o
+    // Source inteiro, do mesmo jeito que recusa um destinatario sujo.
+    it('apara espaco no email e no nome, como o getReplyToAddress ja fazia', () => {
+      expect(
+        getFromAddress({ from_email: ' a@b.com ', from_name: ' Alice ' }),
+      ).toBe('Alice <a@b.com>');
+      expect(getFromAddress({ from_email: ' a@b.com ' })).toBe('a@b.com');
+    });
   });
 
   describe('getReplyToAddress', () => {