@hed-hog/core 0.0.390 → 0.0.394

package/src/access-log/access-log.service.spec.ts

@@ -78,6 +78,7 @@ describe('AccessLogService', () => {
           user_agent: 'UA',
           method: 'GET',
           path: '/api/x',
+          impersonator_user_id: null,
         },
       });
     });
@@ -89,7 +90,32 @@ describe('AccessLogService', () => {
       service.recordHttp({ method: 'POST', path: '/x' });
 
       expect(prisma.access_log.create).toHaveBeenCalledWith({
-        data: { user_id: null, ip: null, user_agent: null, method: 'POST', path: '/x' },
+        data: {
+          user_id: null,
+          ip: null,
+          user_agent: null,
+          method: 'POST',
+          path: '/x',
+          impersonator_user_id: null,
+        },
+      });
+    });
+
+    it('grava o operador quando o acesso e simulado', () => {
+      const { service, prisma } = makeService();
+      prisma.access_log.create.mockResolvedValue({});
+
+      // `userId` continua sendo o ALVO; o operador entra numa coluna propria,
+      // senao o log fica indistinguivel de um acesso genuino do usuario.
+      service.recordHttp({
+        userId: 3,
+        method: 'GET',
+        path: '/api/x',
+        impersonatorUserId: 42,
+      });
+
+      expect(prisma.access_log.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({ user_id: 3, impersonator_user_id: 42 }),
       });
     });
 
@@ -115,7 +141,12 @@ describe('AccessLogService', () => {
       service.recordMcp({ userId: 9, mcpTool: 'search', mcpPrompt: 'q' });
 
       expect(prisma.access_log.create).toHaveBeenCalledWith({
-        data: { user_id: 9, mcp_tool: 'search', mcp_prompt: 'q' },
+        data: {
+          user_id: 9,
+          mcp_tool: 'search',
+          mcp_prompt: 'q',
+          impersonator_user_id: null,
+        },
       });
     });
   });

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

@@ -10,12 +10,15 @@ interface RecordHttpData {
   userAgent?: string;
   method: string;
   path: string;
+  /** Operador por tras de um acesso simulado; `userId` continua sendo o alvo. */
+  impersonatorUserId?: number;
 }
 
 interface RecordMcpData {
   userId?: number;
   mcpTool: string;
   mcpPrompt?: string;
+  impersonatorUserId?: number;
 }
 
 type AccessLogListParams = {
@@ -30,6 +33,7 @@ type AccessLogListParams = {
   createdAtFrom?: string;
   createdAtTo?: string;
   type?: 'http' | 'mcp' | 'all';
+  simulated?: 'all' | 'only' | 'exclude';
 };
 
 @Injectable()
@@ -52,6 +56,7 @@ export class AccessLogService {
           user_agent: data.userAgent ?? null,
           method: data.method,
           path: data.path,
+          impersonator_user_id: data.impersonatorUserId ?? null,
         },
       })
       .catch((e) => this.logger.warn(`Failed to persist HTTP access log: ${e.message}`));
@@ -64,6 +69,7 @@ export class AccessLogService {
           user_id: data.userId ?? null,
           mcp_tool: data.mcpTool,
           mcp_prompt: data.mcpPrompt ?? null,
+          impersonator_user_id: data.impersonatorUserId ?? null,
         },
       })
       .catch((e) => this.logger.warn(`Failed to persist MCP access log: ${e.message}`));
@@ -102,6 +108,12 @@ export class AccessLogService {
       where.mcp_tool = { not: null };
     }
 
+    if (params.simulated === 'only') {
+      where.impersonator_user_id = { not: null };
+    } else if (params.simulated === 'exclude') {
+      where.impersonator_user_id = null;
+    }
+
     const result = await this.pagination.paginate(this.prisma.access_log, {
       ...params,
       fields: params.fields ?? '',
@@ -113,6 +125,24 @@ export class AccessLogService {
       },
     });
 
+    // `impersonator_user_id` e INT puro, sem FK (senao o db pull renomearia a
+    // relacao `user.access_log`), entao o nome do operador vem de uma consulta
+    // separada sobre os ids desta pagina.
+    const impersonatorIds = Array.from(
+      new Set(
+        (result.data as any[])
+          .map((log) => log.impersonator_user_id)
+          .filter((id): id is number => typeof id === 'number'),
+      ),
+    );
+    const impersonators = impersonatorIds.length
+      ? await this.prisma.user.findMany({
+          where: { id: { in: impersonatorIds } },
+          select: { id: true, name: true, photo_id: true },
+        })
+      : [];
+    const impersonatorById = new Map(impersonators.map((user) => [user.id, user]));
+
     const data = (result.data as any[]).map((log) => {
       const ua = log.user_agent ? new UAParser(log.user_agent).getResult() : null;
       const geo = log.ip ? geoip.lookup(log.ip) : null;
@@ -124,6 +154,14 @@ export class AccessLogService {
         os_version: ua?.os?.version ?? null,
         country: geo?.country ?? null,
         city: geo?.city ?? null,
+        impersonator:
+          typeof log.impersonator_user_id === 'number'
+            ? (impersonatorById.get(log.impersonator_user_id) ?? {
+                id: log.impersonator_user_id,
+                name: '',
+                photo_id: null,
+              })
+            : null,
       };
     });
 

package/src/access-log/dto/query-access-log.dto.ts

@@ -20,4 +20,9 @@ export class QueryAccessLogDto {
   @IsOptional()
   @IsIn(['http', 'mcp', 'all'])
   type?: 'http' | 'mcp' | 'all';
+
+  /** Filtra acessos feitos durante uma simulacao de acesso. */
+  @IsOptional()
+  @IsIn(['all', 'only', 'exclude'])
+  simulated?: 'all' | 'only' | 'exclude';
 }

package/src/ai/ai.controller.ts

@@ -7,7 +7,9 @@ import { AiService } from './ai.service';
 import { ChatAgentDTO } from './dto/chat-agent.dto';
 import { ChatDTO } from './dto/chat.dto';
 import { CreateAgentDTO } from './dto/create-agent.dto';
+import { RichtextEditHtmlDTO } from './dto/richtext-edit-html.dto';
 import { UpdateAgentDTO } from './dto/update-agent.dto';
+import { RichtextAiService } from './richtext-ai.service';
 
 @Role()
 @Controller('ai')
@@ -15,6 +17,8 @@ export class AiController {
   constructor(
     @Inject(forwardRef(() => AiService))
     private readonly aiService: AiService,
+    @Inject(forwardRef(() => RichtextAiService))
+    private readonly richtextAiService: RichtextAiService,
   ) {}
 
   @Post('chat')
@@ -65,4 +69,9 @@ export class AiController {
   ) {
     return this.aiService.chatWithAgent(slug, data, file);
   }
+
+  @Post('richtext/edit-html')
+  async editRichtextHtml(@Body() data: RichtextEditHtmlDTO) {
+    return this.richtextAiService.editHtml(data);
+  }
 }

package/src/ai/ai.module.ts

@@ -5,6 +5,7 @@ import { FileModule } from '../file/file.module';
 import { SettingModule } from '../setting/setting.module';
 import { AiController } from './ai.controller';
 import { AiService } from './ai.service';
+import { RichtextAiService } from './richtext-ai.service';
 
 @Module({
   imports: [
@@ -14,7 +15,7 @@ import { AiService } from './ai.service';
     forwardRef(() => AiInstructionModule),
   ],
   controllers: [AiController],
-  providers: [AiService],
-  exports: [AiService],
+  providers: [AiService, RichtextAiService],
+  exports: [AiService, RichtextAiService],
 })
 export class AiModule {}

package/src/ai/ai.service.ts

@@ -40,7 +40,7 @@ import { ChatDTO } from './dto/chat.dto';
 import { CreateAgentDTO } from './dto/create-agent.dto';
 import { UpdateAgentDTO } from './dto/update-agent.dto';
 
-type AiProvider = 'openai' | 'gemini' | 'deepseek';
+type AiProvider = 'openai' | 'gemini' | 'deepseek' | 'claude';
 
 /** Fallback call timeout when the active AI integration profile doesn't set `timeout_ms`. */
 const DEFAULT_AI_CALL_TIMEOUT_MS = 120_000;
@@ -50,6 +50,20 @@ const AI_PROFILE_SETTING: Record<AiProvider, string> = {
   openai: 'ai-openai-profile-id',
   gemini: 'ai-gemini-profile-id',
   deepseek: 'ai-deepseek-profile-id',
+  claude: 'ai-claude-profile-id',
+};
+
+/**
+ * Slug do provider de integração -> provider do chat.
+ *
+ * Usado quando o chamador escolhe um PERFIL (e não um provider): o provider sai
+ * do perfil, não do setting global.
+ */
+const PROVIDER_BY_INTEGRATION_SLUG: Record<string, AiProvider> = {
+  openai: 'openai',
+  gemini: 'gemini',
+  deepseek: 'deepseek',
+  claude: 'claude',
 };
 
 /**
@@ -82,6 +96,14 @@ type AiAttachment = {
   buffer: Buffer;
 };
 
+type AiProfileCredentials = {
+  apiKey: string;
+  organization?: string;
+  model?: string;
+  timeoutMs?: number;
+  baseUrl?: string;
+};
+
 @Injectable()
 export class AiService implements OnModuleInit {
   private readonly logger = new Logger(AiService.name);
@@ -170,6 +192,14 @@ export class AiService implements OnModuleInit {
     userPromptSlug: string;
     variables?: TemplateVars;
     provider?: AiProvider;
+    /**
+     * Perfil de integração a usar, no lugar do setting global por provider.
+     *
+     * Quando presente, o provider vem do perfil — é o que permite um módulo
+     * (o SAC, por exemplo) ter o próprio perfil de IA sem afetar o resto do
+     * sistema. Mesmo padrão que `sendTemplatedMail` já usa para e-mail.
+     */
+    profileSlug?: string;
     params?: AiChatModelParams;
     contextSlug?: string;
   }): Promise<{
@@ -194,8 +224,14 @@ export class AiService implements OnModuleInit {
     // The system prompt represents the call, so its params win over the user one.
     const stored = mergeModelParams(systemPrompt, userPrompt);
 
-    const provider = input.provider || (await this.getDefaultProvider());
-    const aiProfile = await this.getAiProfile(provider);
+    // Um perfil explícito manda no provider: pedir "openai" e apontar um perfil
+    // Claude bateria na API errada com a chave errada.
+    const target = await this.resolveProviderAndProfile(
+      input.provider,
+      input.profileSlug,
+    );
+    const provider = target.provider;
+    const aiProfile = target.profile;
     const model =
       stored.model || aiProfile.model || this.getDefaultModel(provider);
     const timeoutMs = aiProfile.timeoutMs ?? DEFAULT_AI_CALL_TIMEOUT_MS;
@@ -582,6 +618,10 @@ export class AiService implements OnModuleInit {
       return DEEPSEEK_DEFAULT_MODEL;
     }
 
+    if (provider === 'claude') {
+      return 'claude-sonnet-4-5';
+    }
+
     return 'gpt-4o-mini';
   }
 
@@ -615,6 +655,10 @@ export class AiService implements OnModuleInit {
       return this.chatWithGemini(input);
     }
 
+    if (provider === 'claude') {
+      return this.chatWithClaude(input);
+    }
+
     if (provider === 'deepseek') {
       return this.chatWithOpenAi({
         ...input,
@@ -631,16 +675,42 @@ export class AiService implements OnModuleInit {
     return (await this.getAiProfile(provider)).apiKey;
   }
 
+  /**
+   * Resolve provider e credenciais juntos.
+   *
+   * Com `profileSlug`, o provider vem do perfil — o chamador escolheu uma conta
+   * concreta, e o setting global do provider não tem nada a dizer sobre ela.
+   */
+  private async resolveProviderAndProfile(
+    provider?: AiProvider,
+    profileSlug?: string,
+  ): Promise<{ provider: AiProvider; profile: AiProfileCredentials }> {
+    const slug = String(profileSlug ?? '').trim();
+
+    if (!slug) {
+      const resolvedProvider = provider || (await this.getDefaultProvider());
+      return {
+        provider: resolvedProvider,
+        profile: await this.getAiProfile(resolvedProvider),
+      };
+    }
+
+    const profile = await this.loadAiProfileBySlug(slug);
+    const providerSlug = profile.providerSlug;
+    const mapped = PROVIDER_BY_INTEGRATION_SLUG[providerSlug];
+
+    if (!mapped) {
+      throw new BadRequestException(
+        `AI profile "${slug}" uses provider "${providerSlug}", which is not supported for chat. ` +
+          `Use one of: ${Object.keys(PROVIDER_BY_INTEGRATION_SLUG).join(', ')}.`,
+      );
+    }
+
+    return { provider: mapped, profile: profile.config };
+  }
+
   /** Resolves the active AI integration profile's credentials plus its optional model/timeout overrides. */
-  private async getAiProfile(
-    provider: AiProvider,
-  ): Promise<{
-    apiKey: string;
-    organization?: string;
-    model?: string;
-    timeoutMs?: number;
-    baseUrl?: string;
-  }> {
+  private async getAiProfile(provider: AiProvider): Promise<AiProfileCredentials> {
     const slug = AI_PROFILE_SETTING[provider] ?? AI_PROFILE_SETTING.openai;
     const settings = await this.settingService.getSettingValues([slug]);
     const profileSlug = String(settings[slug] ?? '').trim();
@@ -651,6 +721,13 @@ export class AiService implements OnModuleInit {
       );
     }
 
+    return (await this.loadAiProfileBySlug(profileSlug)).config;
+  }
+
+  private async loadAiProfileBySlug(profileSlug: string): Promise<{
+    providerSlug: string;
+    config: AiProfileCredentials;
+  }> {
     const profile = await this.prismaService.integration_profile.findUnique({
       where: { slug: profileSlug },
       include: { integration_provider: { select: { slug: true } } },
@@ -669,7 +746,7 @@ export class AiService implements OnModuleInit {
       throw new BadRequestException(`AI profile "${profileSlug}" has no API key configured.`);
     }
 
-    return aiConfig;
+    return { providerSlug: profile.integration_provider.slug, config: aiConfig };
   }
 
   /** Rejects with a timeout error if `promise` doesn't settle within `ms`. */
@@ -750,6 +827,66 @@ export class AiService implements OnModuleInit {
     };
   }
 
+  /**
+   * Anthropic (Claude).
+   *
+   * A API é diferente da da OpenAI em três pontos que quebram se reusarmos
+   * aquele caminho: autentica por `x-api-key` (não Bearer), exige o header de
+   * versão, e o system prompt é um campo à parte em vez de uma mensagem com
+   * `role: system`. `max_tokens` é obrigatório — sem ele a requisição é
+   * recusada, daí o padrão.
+   *
+   * Anexo não é suportado aqui: a Anthropic recebe imagem como bloco base64, e
+   * nenhum chamador do SAC manda anexo para o modelo.
+   */
+  private async chatWithClaude({
+    message,
+    model,
+    systemPrompt,
+    apiKey,
+    params,
+  }: {
+    message: string;
+    model: string;
+    systemPrompt?: string;
+    apiKey?: string;
+    params?: AiChatModelParams;
+  }): Promise<{ content: string; usage?: { input: number; output: number; total: number } }> {
+    const key = apiKey ?? (await this.getAiApiKey('claude'));
+
+    const body: Record<string, unknown> = {
+      model,
+      max_tokens: params?.maxTokens ?? 4096,
+      messages: [{ role: 'user', content: message }],
+    };
+    if (systemPrompt) body.system = systemPrompt;
+    if (params?.temperature !== undefined && params?.temperature !== null) {
+      body.temperature = params.temperature;
+    }
+
+    const response = await axios.post('https://api.anthropic.com/v1/messages', body, {
+      headers: {
+        'x-api-key': key,
+        'anthropic-version': '2023-06-01',
+        'Content-Type': 'application/json',
+      },
+    });
+
+    const content = response.data?.content?.[0]?.text ?? '';
+    const u = response.data?.usage;
+
+    return {
+      content,
+      usage: u
+        ? {
+            input: u.input_tokens ?? 0,
+            output: u.output_tokens ?? 0,
+            total: (u.input_tokens ?? 0) + (u.output_tokens ?? 0),
+          }
+        : undefined,
+    };
+  }
+
   private async createOpenAiAssistant({
     slug,
     model,

package/src/ai/dto/richtext-edit-html.dto.ts

@@ -0,0 +1,11 @@
+import { IsNotEmpty, IsOptional, IsString } from 'class-validator';
+
+export class RichtextEditHtmlDTO {
+  @IsOptional()
+  @IsString()
+  html?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  instruction: string;
+}

package/src/ai/richtext-ai.prompts.ts

@@ -0,0 +1,57 @@
+import { registerAiPrompts } from '../ai-instruction/ai-prompt-registry';
+
+export const RICHTEXT_AI_PROMPT_SLUGS = {
+  editHtmlSystem: 'task.core.richtext-html.edit.system',
+  editHtmlUser: 'task.core.richtext-html.edit.user',
+} as const;
+
+const EDIT_HTML_SYSTEM_PROMPT = `Você é um editor especialista em HTML de conteúdo administrativo. Sua tarefa é ajustar o HTML atual de um editor de texto rico seguindo a instrução de um administrador autenticado.
+
+REGRAS:
+1. Responda com o HTML completo e final do conteúdo, e NADA MAIS: sem cercas de código (\`\`\`), sem markdown, sem comentários ou explicações antes ou depois.
+2. Faça APENAS o ajuste pedido na instrução. Preserve todo o resto do HTML (estrutura, textos, estilos, imagens, links) exatamente como estava.
+3. Use apenas tags e formatação compatíveis com um editor de texto rico comum (parágrafos, títulos, negrito, itálico, sublinhado, listas, links, imagens) — nada de \`<script>\`, \`<style>\` externo ou recursos que o editor não consiga exibir.
+4. Se o HTML de entrada estiver vazio, gere um HTML simples e razoável que atenda à instrução.`;
+
+const EDIT_HTML_USER_PROMPT = `HTML ATUAL DO CONTEÚDO
+<<<HTML
+{{currentHtml}}
+HTML>>>
+
+INSTRUÇÃO DO ADMINISTRADOR
+<<<INSTRUCAO
+{{instruction}}
+INSTRUCAO>>>
+
+Responda apenas com o HTML completo e atualizado.`;
+
+registerAiPrompts([
+  {
+    slug: RICHTEXT_AI_PROMPT_SLUGS.editHtmlSystem,
+    name: 'Ajuste de HTML do editor de texto rico por IA (sistema)',
+    moduleSlug: 'core',
+    locale: 'pt',
+    fallback: EDIT_HTML_SYSTEM_PROMPT,
+    variables: {},
+    defaults: { temperature: 0.3, maxTokens: 8000 },
+  },
+  {
+    slug: RICHTEXT_AI_PROMPT_SLUGS.editHtmlUser,
+    name: 'Ajuste de HTML do editor de texto rico por IA (usuário)',
+    moduleSlug: 'core',
+    locale: 'pt',
+    fallback: EDIT_HTML_USER_PROMPT,
+    variables: {
+      currentHtml: {
+        type: 'string',
+        required: true,
+        description: 'HTML atual do conteúdo do editor (pode estar vazio).',
+      },
+      instruction: {
+        type: 'string',
+        required: true,
+        description: 'Instrução em linguagem natural pedida pelo administrador.',
+      },
+    },
+  },
+]);

package/src/ai/richtext-ai.service.ts

@@ -0,0 +1,109 @@
+import {
+  BadRequestException,
+  forwardRef,
+  Inject,
+  Injectable,
+} from '@nestjs/common';
+import { SettingService } from '../setting/setting.service';
+import { AiService } from './ai.service';
+import { RICHTEXT_AI_PROMPT_SLUGS } from './richtext-ai.prompts';
+
+/** HTML maior que isso é documento inteiro, não um trecho de conteúdo — evita custo/contexto sem sentido. */
+const MAX_HTML_CHARS = 60_000;
+
+/** Instrução maior que isso é um briefing, não um ajuste pontual. */
+const MAX_INSTRUCTION_CHARS = 2_000;
+
+export type RichtextAiEditResult = {
+  html: string;
+  provider: string;
+  model: string;
+};
+
+/**
+ * Ajusta o HTML do editor de texto rico compartilhado do admin
+ * (`apps/admin/src/components/rich-text-editor.tsx`) a partir de um prompt em
+ * linguagem natural.
+ *
+ * Todo o trabalho pesado (multi-provider, prompts com override no banco,
+ * registro de custo em `ai_execution`) é do `AiService` do core — aqui só se
+ * lê a setting `richtext-ai-*` e se monta o contexto. Não persiste nada: quem
+ * decide salvar o HTML devolvido é o próprio editor, via `onChange`.
+ */
+@Injectable()
+export class RichtextAiService {
+  constructor(
+    @Inject(forwardRef(() => SettingService))
+    private readonly settings: SettingService,
+    @Inject(forwardRef(() => AiService))
+    private readonly ai: AiService,
+  ) {}
+
+  async editHtml(
+    input: { html?: string | null; instruction?: string | null },
+  ): Promise<RichtextAiEditResult> {
+    const config = await this.getAiConfig();
+
+    if (!config.enabled) {
+      throw new BadRequestException(
+        'AI rich text editing is disabled. Enable it in Settings → AI.',
+      );
+    }
+    if (!config.profileSlug) {
+      throw new BadRequestException(
+        'No AI profile configured for the rich text editor. Set one in Settings → AI.',
+      );
+    }
+
+    const instruction = String(input.instruction ?? '')
+      .trim()
+      .slice(0, MAX_INSTRUCTION_CHARS);
+    if (!instruction) {
+      throw new BadRequestException('Instruction is required.');
+    }
+
+    const currentHtml = String(input.html ?? '').slice(0, MAX_HTML_CHARS);
+
+    const result = await this.ai.chatWithPrompt({
+      systemPromptSlug: RICHTEXT_AI_PROMPT_SLUGS.editHtmlSystem,
+      userPromptSlug: RICHTEXT_AI_PROMPT_SLUGS.editHtmlUser,
+      variables: { currentHtml, instruction },
+      profileSlug: config.profileSlug,
+      contextSlug: 'richtext.edit-html',
+    });
+
+    const html = this.extractHtml(result.content);
+    if (!html) {
+      throw new BadRequestException('The model returned an empty HTML.');
+    }
+
+    return { html, provider: result.provider, model: result.model };
+  }
+
+  private async getAiConfig(): Promise<{
+    enabled: boolean;
+    profileSlug: string | null;
+  }> {
+    const slugs = ['richtext-ai-enabled', 'richtext-ai-profile-id'];
+    const values = await this.settings.getSettingValues(slugs);
+
+    const enabled = ['true', '1'].includes(
+      String(values['richtext-ai-enabled'] ?? '').trim().toLowerCase(),
+    );
+    const profileSlug =
+      String(values['richtext-ai-profile-id'] ?? '').trim() || null;
+
+    return { enabled, profileSlug };
+  }
+
+  /**
+   * O prompt de sistema já pede HTML puro, mas alguns modelos insistem em
+   * cercar a resposta com ```html ... ``` mesmo assim. Remove a cerca quando
+   * presente para não gravar markdown como se fosse o conteúdo.
+   */
+  private extractHtml(content: string): string {
+    const trimmed = content.trim();
+    const fenced = /^```(?:html)?\s*([\s\S]*?)\s*```$/i.exec(trimmed);
+    return (fenced ? fenced[1] : trimmed).trim();
+  }
+}