@hed-hog/core 0.0.387 → 0.0.390

package/hedhog/table/leaked_password.yaml

@@ -0,0 +1,18 @@
+columns:
+  - type: pk
+  # SHA-1 da senha em claro, 20 bytes. SHA-1 porque e o formato em que os corpus
+  # publicos de vazamento (Pwned Passwords) sao distribuidos — aqui ele e
+  # identificador de item de lista publica, nao protecao de senha. As senhas do
+  # sistema continuam em hash de senha proprio e as do cofre em Argon2id+AES-GCM.
+  - name: hash
+    type: bytes
+    isUnique: true
+  # Quantas vezes o hash apareceu nos vazamentos conhecidos, quando o dump
+  # informa. 0 = desconhecido (caso do seed base, que vem de lista curada).
+  - name: occurrences
+    type: int
+    default: 0
+  - type: created_at
+
+indices:
+  - columns: [occurrences]

package/hedhog/table/mail_layout.yaml

@@ -0,0 +1,35 @@
+columns:
+  - type: pk
+  - type: slug
+  - name: is_default
+    type: boolean
+    default: false
+    comment: "Layout applied to every mail that does not skip or override it"
+  - name: wrapper
+    type: text
+    comment: "Full HTML document with {{{header}}} / {{{content}}} / {{{footer}}} tokens. Structural (CSS) and therefore not translatable."
+  - name: name
+    type: locale_varchar
+    length: 255
+    locale:
+      en: Name
+      pt: Nome
+  - name: header
+    type: locale_text
+    isNullable: true
+    locale:
+      en: Header
+      pt: Cabeçalho
+  - name: footer
+    type: locale_text
+    isNullable: true
+    locale:
+      en: Footer
+      pt: Rodapé
+  - type: created_at
+  - type: updated_at
+
+indices:
+  - columns: [is_default]
+    isUnique: true
+    where: is_default = true

package/hedhog/table/mail_var.yaml

@@ -10,3 +10,7 @@ columns:
   - name: name
   - type: created_at
   - type: updated_at
+
+indices:
+  - columns: [mail_id, name]
+    isUnique: true

package/hedhog/table/setting.yaml

@@ -33,6 +33,7 @@ columns:
       - switch
       - checkbox
       - entity-picker
+      - link
     default: input-text
   - name: value
     length: 1023

package/hedhog/table/system_incident.yaml

@@ -0,0 +1,59 @@
+columns:
+  - type: pk
+  # Origem no formato "<modulo>.<area>", ex.: core.mail, legacy.reconcile.
+  - name: source
+    type: varchar
+    length: 120
+  # Identificador estavel da falha, ex.: mail_send_failed.
+  - name: code
+    type: varchar
+    length: 120
+  - name: severity
+    type: enum
+    values:
+      - warning
+      - error
+      - critical
+    default: error
+  - name: message
+    type: text
+  - name: context
+    type: json
+    isNullable: true
+  # Hash de (source, code, chave de agrupamento). E o que impede uma falha
+  # repetitiva de virar milhares de linhas: repeticao vira contador.
+  - name: fingerprint
+    type: varchar
+    length: 64
+    isUnique: true
+  - name: occurrences
+    type: int
+    default: 1
+  - name: first_seen_at
+    type: datetime
+  - name: last_seen_at
+    type: datetime
+  # Ultima vez que este incidente gerou aviso; base do cooldown.
+  - name: notified_at
+    type: datetime
+    isNullable: true
+  - name: resolved_at
+    type: datetime
+    isNullable: true
+  - name: resolved_by
+    type: fk
+    isNullable: true
+    references:
+      table: user
+      column: id
+      onDelete: SET NULL
+      onUpdate: CASCADE
+  - type: created_at
+  - type: updated_at
+
+indices:
+  - columns: [source]
+  - columns: [code]
+  - columns: [severity]
+  - columns: [resolved_at]
+  - columns: [last_seen_at]

package/hedhog/table/user_presence.yaml

@@ -0,0 +1,36 @@
+# Unified presence per user: app heartbeat (real-time, this application) merged
+# with Microsoft Teams presence (when the Teams integration is configured). One
+# row per user, upserted by the heartbeat endpoint and by the Microsoft presence
+# processor.
+columns:
+  - type: pk
+  - name: user_id
+    type: fk
+    references:
+      table: user
+      column: id
+      onDelete: CASCADE
+      onUpdate: CASCADE
+  # Last time the user's browser pinged the heartbeat endpoint (app presence).
+  - name: last_heartbeat_at
+    type: timestamptz
+    isNullable: true
+  # Latest Microsoft Teams presence (Available/Busy/Away/DoNotDisturb/Offline/...).
+  - name: teams_availability
+    type: varchar
+    length: 64
+    isNullable: true
+  - name: teams_activity
+    type: varchar
+    length: 64
+    isNullable: true
+  - name: teams_updated_at
+    type: timestamptz
+    isNullable: true
+  - type: created_at
+  - type: updated_at
+
+indices:
+  - columns: [user_id]
+    isUnique: true
+  - columns: [last_heartbeat_at]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hed-hog/core",
-  "version": "0.0.387",
+  "version": "0.0.390",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,8 +20,10 @@
     "@nestjs/event-emitter": "*",
     "@nestjs/jwt": "^11",
     "@nestjs/mapped-types": "*",
+    "@nestjs/platform-socket.io": "^11",
     "@nestjs/schedule": "^6.0.1",
     "@nestjs/throttler": "^6.4.0",
+    "@nestjs/websockets": "^11",
     "@simplewebauthn/server": "^13.2.2",
     "argon2": "^0.44.0",
     "axios": "^1.9.0",
@@ -37,16 +39,18 @@
     "qrcode": "^1.5.4",
     "redis": "4.7.1",
     "rxjs": "^7.8.2",
+    "socket.io": "^4.8.1",
     "sharp": "^0.34.2",
     "speakeasy": "^2.0.0",
     "ua-parser-js": "^2.0.10",
     "uuid": "^11.1.0",
     "@hed-hog/api-prisma": "0.0.6",
+    "@hed-hog/api-locale": "0.0.14",
+    "@hed-hog/vault-crypto": "0.0.1",
+    "@hed-hog/api": "0.0.8",
     "@hed-hog/api-types": "0.0.1",
     "@hed-hog/api-mail": "0.0.9",
-    "@hed-hog/api-pagination": "0.0.7",
-    "@hed-hog/api-locale": "0.0.14",
-    "@hed-hog/api": "0.0.8"
+    "@hed-hog/api-pagination": "0.0.7"
   },
   "exports": {
     ".": {

package/src/access-log/access-log.interceptor.ts

@@ -26,8 +26,10 @@ export class AccessLogInterceptor implements NestInterceptor {
     return next.handle().pipe(
       tap(() => {
         const userId: number | undefined = request.auth?.sub;
-        const forwarded = request.headers['x-forwarded-for'] as string | undefined;
-        const ip: string = forwarded ? forwarded.split(',')[0].trim() : (request.ip ?? '');
+        // request.ip já resolve o IP real do cliente respeitando `trust proxy` (main.ts):
+        // ler x-forwarded-for na mão aqui pegava o primeiro valor da lista, que é
+        // exatamente o mais fácil de forjar pelo próprio cliente.
+        const ip: string = request.ip ?? '';
         const userAgent: string = (request.headers['user-agent'] as string) ?? '';
         const method: string = request.method ?? '';
 

package/src/ai/ai-attachment.fragments.spec.ts

@@ -0,0 +1,319 @@
+import axios from 'axios';
+import {
+  attachedFileBlock,
+  binaryAttachmentMarker,
+  unreadablePdfMarker,
+} from './ai-attachment.fragments';
+import { AiService } from './ai.service';
+
+jest.mock('axios');
+
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+/**
+ * Fidelidade byte a byte da extração.
+ *
+ * As funções `legacy*` abaixo são cópias literais do que `chatWithGemini` e
+ * `buildOpenAiUserContent` montavam inline antes dos marcadores virarem helpers
+ * — `[Attached file: …]` estava triplicado, `[Binary attachment: …]` e
+ * `[PDF attachment with unreadable text: …]` moram no mesmo bloco. Um `\n`
+ * perdido ou um espaço a mais em torno dos `|` muda o que o modelo recebe SEM
+ * levantar erro algum. Este é o único check que pega isso — não "arrume" estas
+ * cópias.
+ *
+ * Repare no ponto delicado: no legado do OpenAI o `\n\n` ficava no template do
+ * `return`, e agora vem de dentro de `attachedFileBlock`. Os bytes finais são os
+ * mesmos, e é exatamente isso que `legacyOpenAiReturn` prova.
+ */
+
+type LegacyAttachment = { filename: string; mimeType: string; buffer: Buffer };
+
+function legacyGeminiTextPart(attachment: LegacyAttachment, utf8Text: string): string {
+  return `\n\n[Attached file: ${attachment.filename}]\n${utf8Text}`;
+}
+
+function legacyGeminiPdfPart(attachment: LegacyAttachment, pdfText: string): string {
+  return `\n\n[Attached file: ${attachment.filename}]\n${pdfText}`;
+}
+
+function legacyUnreadablePdf(attachment: LegacyAttachment): string {
+  return `[PDF attachment with unreadable text: ${attachment.filename}]`;
+}
+
+function legacyBinaryMarker(attachment: LegacyAttachment): string {
+  return `[Binary attachment: ${attachment.filename} | ${attachment.mimeType} | ${attachment.buffer.length} bytes]`;
+}
+
+function legacyOpenAiReturn(
+  message: string,
+  attachment: LegacyAttachment,
+  text: string,
+): string {
+  return `${message}\n\n[Attached file: ${attachment.filename}]\n${text}`;
+}
+
+function makeAttachment(
+  filename: string,
+  mimeType: string,
+  content: string,
+): LegacyAttachment {
+  return { filename, mimeType, buffer: Buffer.from(content, 'utf8') };
+}
+
+const TEXT_ATTACHMENT = makeAttachment('notas.txt', 'text/plain', 'linha 1\nlinha 2');
+const PDF_ATTACHMENT = makeAttachment('contrato.pdf', 'application/pdf', '%PDF-1.4');
+const BINARY_ATTACHMENT = makeAttachment('planilha.xlsx', 'application/octet-stream', 'PK');
+
+describe('marcadores de anexo — fidelidade', () => {
+  it('bloco de arquivo de texto é idêntico ao original do Gemini', () => {
+    const utf8Text = TEXT_ATTACHMENT.buffer.toString('utf8');
+
+    expect(attachedFileBlock(TEXT_ATTACHMENT.filename, utf8Text)).toBe(
+      legacyGeminiTextPart(TEXT_ATTACHMENT, utf8Text),
+    );
+  });
+
+  it('bloco de PDF extraído é idêntico ao original do Gemini', () => {
+    const pdfText = 'Cláusula 1ª — objeto do contrato.';
+
+    expect(attachedFileBlock(PDF_ATTACHMENT.filename, pdfText)).toBe(
+      legacyGeminiPdfPart(PDF_ATTACHMENT, pdfText),
+    );
+  });
+
+  it('bloco do OpenAI é idêntico ao original mesmo com o \\n\\n vindo do helper', () => {
+    const message = 'Resuma o anexo.';
+    const text = TEXT_ATTACHMENT.buffer.toString('utf8');
+
+    expect(`${message}${attachedFileBlock(TEXT_ATTACHMENT.filename, text)}`).toBe(
+      legacyOpenAiReturn(message, TEXT_ATTACHMENT, text),
+    );
+  });
+
+  it('marcador de binário é idêntico ao original, com os pipes espaçados', () => {
+    expect(
+      binaryAttachmentMarker(
+        BINARY_ATTACHMENT.filename,
+        BINARY_ATTACHMENT.mimeType,
+        BINARY_ATTACHMENT.buffer.length,
+      ),
+    ).toBe(legacyBinaryMarker(BINARY_ATTACHMENT));
+
+    expect(binaryAttachmentMarker('a.bin', 'application/octet-stream', 12)).toBe(
+      '[Binary attachment: a.bin | application/octet-stream | 12 bytes]',
+    );
+  });
+
+  it('marcador de PDF ilegível é idêntico ao original', () => {
+    expect(unreadablePdfMarker(PDF_ATTACHMENT.filename)).toBe(
+      legacyUnreadablePdf(PDF_ATTACHMENT),
+    );
+  });
+
+  it('preserva nome de arquivo com espaço, acento e pipe', () => {
+    const weird = makeAttachment('nota fiscal | 2ª via.pdf', 'application/pdf', 'x');
+
+    expect(attachedFileBlock(weird.filename, 'corpo')).toBe(
+      legacyGeminiPdfPart(weird, 'corpo'),
+    );
+    expect(binaryAttachmentMarker(weird.filename, weird.mimeType, weird.buffer.length)).toBe(
+      legacyBinaryMarker(weird),
+    );
+    expect(unreadablePdfMarker(weird.filename)).toBe(legacyUnreadablePdf(weird));
+  });
+
+  it('corpo vazio mantém a quebra final, e zero bytes continua "0 bytes"', () => {
+    const empty = makeAttachment('vazio.txt', 'text/plain', '');
+
+    expect(attachedFileBlock(empty.filename, '')).toBe(legacyGeminiTextPart(empty, ''));
+    expect(attachedFileBlock(empty.filename, '')).toBe('\n\n[Attached file: vazio.txt]\n');
+    expect(binaryAttachmentMarker(empty.filename, empty.mimeType, empty.buffer.length)).toBe(
+      legacyBinaryMarker(empty),
+    );
+  });
+});
+
+/**
+ * O que sai no fio. Este bloco é o que pega "troquei o call site pelo helper
+ * errado" — os asserts comparam o corpo da requisição com as cópias legadas.
+ */
+describe('AiService — anexos no fio', () => {
+  let service: AiService;
+
+  const aiProfile = { apiKey: 'sk-test', model: undefined, timeoutMs: undefined };
+
+  beforeEach(() => {
+    const prisma = {} as any;
+    const settingService = { getSettingValues: jest.fn().mockResolvedValue({}) } as any;
+    const fileService = {} as any;
+    const aiExecution = {
+      start: jest.fn().mockResolvedValue(1),
+      recordStep: jest.fn().mockResolvedValue(undefined),
+      finish: jest.fn().mockResolvedValue(undefined),
+    } as any;
+    const promptResolver = { resolveMany: jest.fn() };
+
+    service = new AiService(prisma, settingService, fileService, aiExecution, promptResolver as any);
+
+    jest.spyOn(service as any, 'getAiProfile').mockResolvedValue(aiProfile);
+    jest.spyOn(service as any, 'getDefaultProvider').mockResolvedValue('openai');
+
+    mockedAxios.post.mockResolvedValue({
+      data: {
+        choices: [{ message: { content: 'ok' } }],
+        candidates: [{ content: { parts: [{ text: 'ok' }] } }],
+      },
+    } as any);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    mockedAxios.post.mockReset();
+  });
+
+  function useAttachment(attachment: LegacyAttachment | null) {
+    jest.spyOn(service as any, 'resolveAttachment').mockResolvedValue(attachment);
+  }
+
+  function lastBody(): Record<string, any> {
+    return mockedAxios.post.mock.calls.at(-1)?.[1] as Record<string, any>;
+  }
+
+  describe('Gemini', () => {
+    it('embrulha anexo de texto exatamente como o código original', async () => {
+      useAttachment(TEXT_ATTACHMENT);
+
+      await service.chat({ message: 'Resuma.', provider: 'gemini' } as any);
+
+      expect(lastBody().contents[0].parts[1].text).toBe(
+        legacyGeminiTextPart(TEXT_ATTACHMENT, TEXT_ATTACHMENT.buffer.toString('utf8')),
+      );
+    });
+
+    it('embrulha PDF com texto extraído exatamente como o código original', async () => {
+      const pdfText = 'Cláusula 1ª — objeto do contrato.';
+      useAttachment(PDF_ATTACHMENT);
+      jest.spyOn(service as any, 'extractPdfText').mockResolvedValue(pdfText);
+
+      await service.chat({ message: 'Resuma.', provider: 'gemini' } as any);
+
+      expect(lastBody().contents[0].parts[1].text).toBe(
+        legacyGeminiPdfPart(PDF_ATTACHMENT, pdfText),
+      );
+    });
+
+    it('PDF ilegível continua indo como inline_data, sem marcador de texto', async () => {
+      useAttachment(PDF_ATTACHMENT);
+      jest.spyOn(service as any, 'extractPdfText').mockResolvedValue('');
+
+      await service.chat({ message: 'Resuma.', provider: 'gemini' } as any);
+
+      const part = lastBody().contents[0].parts[1];
+      expect(part).not.toHaveProperty('text');
+      expect(part.inline_data.mime_type).toBe('application/pdf');
+    });
+
+    it('binário continua indo como inline_data, sem marcador de texto', async () => {
+      useAttachment(BINARY_ATTACHMENT);
+
+      await service.chat({ message: 'Resuma.', provider: 'gemini' } as any);
+
+      const part = lastBody().contents[0].parts[1];
+      expect(part).not.toHaveProperty('text');
+      expect(part.inline_data.mime_type).toBe('application/octet-stream');
+    });
+
+    it('sem anexo, a mensagem vai crua num único part', async () => {
+      useAttachment(null);
+
+      await service.chat({ message: 'Resuma.', provider: 'gemini' } as any);
+
+      expect(lastBody().contents[0].parts).toHaveLength(1);
+      expect(lastBody().contents[0].parts[0].text).toBe('Resuma.');
+    });
+  });
+
+  describe('OpenAI', () => {
+    it('embrulha anexo de texto exatamente como o código original', async () => {
+      useAttachment(TEXT_ATTACHMENT);
+
+      await service.chat({ message: 'Resuma.', provider: 'openai' } as any);
+
+      expect(lastBody().messages[0].content).toBe(
+        legacyOpenAiReturn(
+          'Resuma.',
+          TEXT_ATTACHMENT,
+          TEXT_ATTACHMENT.buffer.toString('utf8'),
+        ),
+      );
+    });
+
+    it('embrulha PDF com texto extraído exatamente como o código original', async () => {
+      const pdfText = 'Cláusula 1ª — objeto do contrato.';
+      useAttachment(PDF_ATTACHMENT);
+      jest.spyOn(service as any, 'extractPdfText').mockResolvedValue(pdfText);
+
+      await service.chat({ message: 'Resuma.', provider: 'openai' } as any);
+
+      expect(lastBody().messages[0].content).toBe(
+        legacyOpenAiReturn('Resuma.', PDF_ATTACHMENT, pdfText),
+      );
+    });
+
+    it('PDF ilegível cai no marcador de PDF, dentro do bloco de arquivo', async () => {
+      useAttachment(PDF_ATTACHMENT);
+      jest.spyOn(service as any, 'extractPdfText').mockResolvedValue('');
+
+      await service.chat({ message: 'Resuma.', provider: 'openai' } as any);
+
+      expect(lastBody().messages[0].content).toBe(
+        legacyOpenAiReturn('Resuma.', PDF_ATTACHMENT, legacyUnreadablePdf(PDF_ATTACHMENT)),
+      );
+    });
+
+    it('binário cai no marcador de binário, dentro do bloco de arquivo', async () => {
+      useAttachment(BINARY_ATTACHMENT);
+
+      await service.chat({ message: 'Resuma.', provider: 'openai' } as any);
+
+      expect(lastBody().messages[0].content).toBe(
+        legacyOpenAiReturn(
+          'Resuma.',
+          BINARY_ATTACHMENT,
+          legacyBinaryMarker(BINARY_ATTACHMENT),
+        ),
+      );
+    });
+
+    it('imagem continua indo por image_url, sem nenhum marcador', async () => {
+      const image = makeAttachment('foto.png', 'image/png', 'binario');
+      useAttachment(image);
+
+      await service.chat({ message: 'Descreva.', provider: 'openai' } as any);
+
+      const content = lastBody().messages[0].content;
+      expect(content[0]).toEqual({ type: 'text', text: 'Descreva.' });
+      expect(content[1].type).toBe('image_url');
+      expect(JSON.stringify(content)).not.toContain('[Attached file:');
+    });
+
+    it('no DeepSeek, imagem cai no marcador de binário (o modelo não tem visão)', async () => {
+      const image = makeAttachment('foto.png', 'image/png', 'binario');
+      useAttachment(image);
+
+      await service.chat({ message: 'Descreva.', provider: 'deepseek' } as any);
+
+      expect(lastBody().messages[0].content).toBe(
+        legacyOpenAiReturn('Descreva.', image, legacyBinaryMarker(image)),
+      );
+    });
+
+    it('sem anexo, a mensagem vai crua — sem \\n\\n pendurado', async () => {
+      useAttachment(null);
+
+      await service.chat({ message: 'Resuma.', provider: 'openai' } as any);
+
+      expect(lastBody().messages[0].content).toBe('Resuma.');
+    });
+  });
+});

package/src/ai/ai-attachment.fragments.ts

@@ -0,0 +1,35 @@
+/**
+ * Framing mecânico de anexo enviado ao modelo — deliberadamente FORA do registry
+ * de `ai_instruction` (ver o docblock de `ai.prompts.ts`).
+ *
+ * Estes marcadores andam em lockstep com `isTextMime`/`isPdfMime`/`extractPdfText`
+ * em `ai.service.ts`: são o que diz ao modelo que o texto a seguir é o conteúdo de
+ * um arquivo, e não a mensagem do usuário. Antes estavam copiados literalmente nos
+ * dois caminhos de provider (Gemini e OpenAI), onde uma cópia podia ser corrigida
+ * e a outra esquecida sem gerar erro nenhum.
+ *
+ * O `\n\n` inicial faz parte do bloco: no Gemini ele abre um `part` separado, no
+ * OpenAI ele é a junta logo depois de `${message}`. Nos dois casos os bytes finais
+ * são exatamente os mesmos.
+ *
+ * Coberto byte a byte por `ai-attachment.fragments.spec.ts` — não "arrume" o texto.
+ */
+
+/** Bloco que embrulha o conteúdo textual extraído de um anexo. */
+export function attachedFileBlock(filename: string, body: string): string {
+  return `\n\n[Attached file: ${filename}]\n${body}`;
+}
+
+/** Usado quando o anexo não é texto nem PDF legível e vai apenas descrito. */
+export function binaryAttachmentMarker(
+  filename: string,
+  mimeType: string,
+  bytes: number,
+): string {
+  return `[Binary attachment: ${filename} | ${mimeType} | ${bytes} bytes]`;
+}
+
+/** Usado quando `extractPdfText` não consegue extrair nada do PDF. */
+export function unreadablePdfMarker(filename: string): string {
+  return `[PDF attachment with unreadable text: ${filename}]`;
+}

package/src/ai/ai.prompts.ts

@@ -0,0 +1,38 @@
+import { registerAiPrompts } from '../ai-instruction/ai-prompt-registry';
+
+/**
+ * Core AI prompts.
+ *
+ * Deliberately NOT moved here: the attachment wrappers (`[Attached file: …]`,
+ * `[Binary attachment: …]`, `[PDF attachment with unreadable text: …]`). Those are
+ * mechanical framing that must stay in lockstep with `isTextMime`/`isPdfMime`/
+ * `buildOpenAiUserContent` on the parsing side — editable prose they are not.
+ * They now live in `ai-attachment.fragments.ts` (single copy, in code), covered
+ * byte for byte by `ai-attachment.fragments.spec.ts`.
+ */
+
+export const CORE_AI_PROMPT_SLUGS = {
+  agentDefaultInstructions: 'task.core.ai-agent.default-instructions.system',
+} as const;
+
+/** Used when an agent is created without explicit instructions. */
+export const AGENT_DEFAULT_INSTRUCTIONS_PROMPT =
+  'You are the assistant identified by slug {{slug}}.';
+
+registerAiPrompts([
+  {
+    slug: CORE_AI_PROMPT_SLUGS.agentDefaultInstructions,
+    name: 'AI agent — instruções padrão',
+    moduleSlug: 'core',
+    locale: 'en',
+    fallback: AGENT_DEFAULT_INSTRUCTIONS_PROMPT,
+    variables: {
+      slug: {
+        type: 'string',
+        required: true,
+        description: 'Slug do agente sendo criado.',
+        sample: 'finance-payable-extractor',
+      },
+    },
+  },
+]);