@hed-hog/core 0.0.399 → 0.0.400

package/src/mcp/mcp-audit.service.ts

@@ -4,6 +4,8 @@ import { AccessLogService } from '../access-log/access-log.service';
 
 interface AuditRecord {
   userId: number;
+  /** Client OAuth externo, ou null para o caminho interno. */
+  clientId?: string | null;
   toolName: string;
   input: Record<string, any>;
   success: boolean;
@@ -21,12 +23,46 @@ export class McpAuditService {
     private readonly accessLogService: AccessLogService,
   ) {}
 
+  /**
+   * Campos que carregam o conteúdo de um arquivo. Serializá-los custa memória à toa e o
+   * que sobraria no log são mil caracteres de base64, que não dizem nada sobre a chamada.
+   */
+  private static readonly REDACTED_FIELDS = ['fileBase64', 'chunkBase64'];
+
+  /**
+   * Troca o conteúdo de arquivo por uma marca antes de serializar.
+   *
+   * Sem isto, `JSON.stringify` de uma chamada com `fileBase64` monta uma string de
+   * dezenas de MB só para o `slice(0, 1000)` logo abaixo jogar fora quase tudo — e o
+   * pedaço que fica é base64, não a informação que a auditoria quer. Com a troca, o log
+   * passa a mostrar os demais argumentos (o id do título, a modalidade escolhida), que é
+   * o que permite reconstruir o que foi feito.
+   */
+  private redact(input: Record<string, any>): Record<string, any> {
+    if (!input || typeof input !== 'object') {
+      return input;
+    }
+
+    const copy: Record<string, any> = { ...input };
+
+    for (const field of McpAuditService.REDACTED_FIELDS) {
+      if (typeof copy[field] === 'string') {
+        copy[field] = `<redacted: ${copy[field].length} chars>`;
+      }
+    }
+
+    return copy;
+  }
+
   async record(data: AuditRecord): Promise<void> {
-    const sanitized = JSON.stringify(data.input).slice(0, 1000);
+    const sanitized = JSON.stringify(this.redact(data.input)).slice(0, 1000);
     try {
       await this.prisma.mcp_tool_call_log.create({
         data: {
           user_id: data.userId || null,
+          // Sem isto a auditoria nao distingue uma acao feita pelo Claude
+          // Desktop de uma feita pelo Claude Code com chave fixa.
+          client_id: data.clientId ?? null,
           tool_name: data.toolName,
           input: sanitized,
           success: data.success,

package/src/mcp/mcp-permission.service.spec.ts

@@ -0,0 +1,197 @@
+import { afterEach, describe, expect, it, jest } from '@jest/globals';
+import { McpPermissionService } from './mcp-permission.service';
+
+const DENIED = ['core.users.assign-role', 'core.settings.set-many'];
+
+const makeService = (denied: string[] = DENIED) => {
+  const prisma = { route: { findMany: jest.fn<any>() } };
+  const setting = {
+    getSettingValues: jest.fn<any>().mockResolvedValue({
+      'mcp-connector-denied-tools': JSON.stringify(denied),
+    }),
+  };
+  return {
+    service: new McpPermissionService(prisma as any, setting as any),
+    prisma,
+    setting,
+  };
+};
+
+describe('McpPermissionService', () => {
+  // restoreAllMocks, e nao so clearAllMocks: o teste de TTL abaixo troca
+  // `Date.now`, e um spy que nao volta vaza para as outras suites do mesmo
+  // processo (jest --runInBand) — falha intermitente em teste alheio.
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.restoreAllMocks();
+  });
+
+  it('devolve as tools concedidas ao usuário', async () => {
+    const { service, prisma } = makeService();
+    prisma.route.findMany.mockResolvedValue([
+      { tool_name: 'core.users.list' },
+      { tool_name: 'core.system.info' },
+    ]);
+
+    const names = await service.getAllowedToolNames(7);
+
+    expect(names).toEqual(new Set(['core.users.list', 'core.system.info']));
+    expect(prisma.route.findMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          type: 'MCP',
+          tool_name: { not: null },
+        }),
+      }),
+    );
+  });
+
+  it('descarta tool_name nulo vindo do banco', async () => {
+    const { service, prisma } = makeService();
+    prisma.route.findMany.mockResolvedValue([
+      { tool_name: 'core.system.info' },
+      { tool_name: null },
+    ]);
+
+    await expect(service.getAllowedToolNames(7)).resolves.toEqual(
+      new Set(['core.system.info']),
+    );
+  });
+
+  // Sem a guarda, `user_id: undefined` faz o Prisma descartar o filtro e a
+  // consulta devolveria toda rota ligada a qualquer papel.
+  it('nega tudo sem usuário, sem consultar o banco', async () => {
+    const { service, prisma } = makeService();
+
+    await expect(service.getAllowedToolNames(undefined as any)).resolves.toEqual(
+      new Set(),
+    );
+    await expect(service.canCall(0, 'core.system.info')).resolves.toBe(false);
+    expect(prisma.route.findMany).not.toHaveBeenCalled();
+  });
+
+  it('reusa o cache dentro do TTL e consulta de novo depois que expira', async () => {
+    const { service, prisma } = makeService();
+    prisma.route.findMany.mockResolvedValue([{ tool_name: 'core.system.info' }]);
+    const now = jest.spyOn(Date, 'now').mockReturnValue(1_000);
+
+    await service.getAllowedToolNames(7);
+    await service.getAllowedToolNames(7);
+    expect(prisma.route.findMany).toHaveBeenCalledTimes(1);
+
+    now.mockReturnValue(1_000 + 30_001);
+    await service.getAllowedToolNames(7);
+    expect(prisma.route.findMany).toHaveBeenCalledTimes(2);
+  });
+
+  it('não vaza o cache de um usuário para outro', async () => {
+    const { service, prisma } = makeService();
+    prisma.route.findMany
+      .mockResolvedValueOnce([{ tool_name: 'core.users.list' }])
+      .mockResolvedValueOnce([{ tool_name: 'core.system.info' }]);
+
+    await expect(service.getAllowedToolNames(7)).resolves.toEqual(
+      new Set(['core.users.list']),
+    );
+    await expect(service.getAllowedToolNames(8)).resolves.toEqual(
+      new Set(['core.system.info']),
+    );
+  });
+
+  describe('canCall', () => {
+    it('autoriza tool concedida e nega a que não está na lista', async () => {
+      const { service, prisma } = makeService();
+      prisma.route.findMany.mockResolvedValue([
+        { tool_name: 'core.system.info' },
+      ]);
+
+      await expect(service.canCall(7, 'core.system.info')).resolves.toBe(true);
+      await expect(service.canCall(7, 'core.users.delete')).resolves.toBe(false);
+    });
+  });
+
+  /**
+   * O teto do conector: um token OAuth externo herda os papeis INTEIROS de quem
+   * autorizou, entao para um admin todas as tools ficariam ao alcance de um
+   * prompt. O caminho interno (chave hedhog_mcp_, JWT de login) nao e afetado.
+   */
+  describe('teto do cliente OAuth externo', () => {
+    it('remove as tools negadas quando a chamada vem de um conector', async () => {
+      const { service, prisma } = makeService();
+      prisma.route.findMany.mockResolvedValue([
+        { tool_name: 'core.users.list' },
+        { tool_name: 'core.users.assign-role' },
+        { tool_name: 'core.settings.set-many' },
+        { tool_name: 'operations.tasks.create' },
+      ]);
+
+      const viaConector = await service.getAllowedToolNames(7, true);
+
+      expect(viaConector.has('core.users.assign-role')).toBe(false);
+      expect(viaConector.has('core.settings.set-many')).toBe(false);
+      // leitura do mesmo dominio continua liberada
+      expect(viaConector.has('core.users.list')).toBe(true);
+      expect(viaConector.has('operations.tasks.create')).toBe(true);
+    });
+
+    it('nao remove nada no caminho interno', async () => {
+      const { service, prisma } = makeService();
+      prisma.route.findMany.mockResolvedValue([
+        { tool_name: 'core.users.assign-role' },
+        { tool_name: 'core.users.list' },
+      ]);
+
+      const interno = await service.getAllowedToolNames(7, false);
+
+      expect(interno.has('core.users.assign-role')).toBe(true);
+      expect(interno.has('core.users.list')).toBe(true);
+    });
+
+    // Sem chave composta, o mesmo usuario usando os dois caminhos receberia o
+    // conjunto errado — o primeiro que passasse pelo cache venceria.
+    it('nao mistura o cache entre conector e caminho interno', async () => {
+      const { service, prisma } = makeService();
+      prisma.route.findMany.mockResolvedValue([
+        { tool_name: 'core.users.assign-role' },
+      ]);
+
+      const viaConector = await service.getAllowedToolNames(7, true);
+      const interno = await service.getAllowedToolNames(7, false);
+
+      expect(viaConector.has('core.users.assign-role')).toBe(false);
+      expect(interno.has('core.users.assign-role')).toBe(true);
+    });
+
+    it('canCall respeita a origem', async () => {
+      const { service, prisma } = makeService();
+      prisma.route.findMany.mockResolvedValue([
+        { tool_name: 'core.users.assign-role' },
+      ]);
+
+      await expect(service.canCall(7, 'core.users.assign-role', true)).resolves.toBe(false);
+      await expect(service.canCall(7, 'core.users.assign-role', false)).resolves.toBe(true);
+    });
+
+    // Setting apagada por engano nao pode virar permissao.
+    it('cai no padrao embutido quando a setting falha ou vem vazia', async () => {
+      for (const quebrada of [
+        { getSettingValues: jest.fn<any>().mockRejectedValue(new Error('db down')) },
+        { getSettingValues: jest.fn<any>().mockResolvedValue({ 'mcp-connector-denied-tools': '[]' }) },
+        { getSettingValues: jest.fn<any>().mockResolvedValue({}) },
+      ]) {
+        const prisma = { route: { findMany: jest.fn<any>() } };
+        prisma.route.findMany.mockResolvedValue([
+          { tool_name: 'core.users.assign-role' },
+          { tool_name: 'operations.tasks.create' },
+        ]);
+        const service = new McpPermissionService(prisma as any, quebrada as any);
+
+        const names = await service.getAllowedToolNames(7, true);
+
+        expect(names.has('core.users.assign-role')).toBe(false);
+        expect(names.has('operations.tasks.create')).toBe(true);
+      }
+    });
+  });
+
+});

package/src/mcp/mcp-permission.service.ts

@@ -0,0 +1,184 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
+import { SettingService } from '../setting/setting.service';
+
+type CacheEntry = { expiresAt: number; names: Set<string> };
+
+/** Setting com as tools que nenhum cliente OAuth externo pode chamar. */
+const DENIED_TOOLS_SETTING = 'mcp-connector-denied-tools';
+
+/**
+ * Quais tools MCP um usuário pode ver e chamar.
+ *
+ * Existe como service — e não inline no guard — porque a mesma resposta é usada
+ * em dois lugares que precisam concordar: o `tools/list`, que decide o que o
+ * cliente enxerga, e o `tools/call`, que decide o que ele executa. Duplicar a
+ * consulta é o caminho conhecido para os dois divergirem: tool que aparece na
+ * lista e devolve 403, ou — pior — tool que some da lista mas continua
+ * chamável.
+ *
+ * A fonte da verdade é a tabela `route` com `type = 'MCP'`, populada pelos
+ * arquivos `route.yaml` das libraries. Tool que existe em código mas não tem
+ * rota semeada não é concedida a ninguém.
+ */
+@Injectable()
+export class McpPermissionService {
+  /**
+   * Curto de propósito: o preço de errar é uma mudança de papel demorar até
+   * meio minuto para valer, e o ganho é não repetir a consulta a cada uma das
+   * centenas de tools de um `tools/list`. O cache é por processo, e a API roda
+   * com várias réplicas — o limite real de propagação é sempre o TTL, nunca a
+   * réplica que respondeu.
+   */
+  private static readonly CACHE_TTL_MS = 30_000;
+
+  /** Teto de usuários em cache antes de podar o que já expirou. */
+  private static readonly CACHE_MAX_ENTRIES = 500;
+
+  /**
+   * Usado quando a setting nao pode ser lida. Escrita no nucleo de seguranca:
+   * usuarios, papeis, rotas, telas, settings e revogacao de sessao. Ler esses
+   * dominios continua liberado — o que se nega e alterar.
+   */
+  private static readonly DEFAULT_DENIED_TOOLS = [
+    'core.roles.create', 'core.roles.delete', 'core.roles.menus.update',
+    'core.roles.routes.update', 'core.roles.screens.update', 'core.roles.update',
+    'core.roles.users.update',
+    'core.routes.create', 'core.routes.delete', 'core.routes.roles.update',
+    'core.routes.screens.update', 'core.routes.update',
+    'core.screens.create', 'core.screens.delete', 'core.screens.roles.update',
+    'core.screens.routes.update', 'core.screens.update',
+    'core.sessions.revoke', 'core.sessions.revoke-all', 'core.sessions.revoke-all-other',
+    'core.settings.delete', 'core.settings.set', 'core.settings.set-many',
+    'core.settings.update-from-slug',
+    'core.users.assign-role', 'core.users.create', 'core.users.delete',
+    'core.users.remove-role', 'core.users.reset-password', 'core.users.update',
+    'core.users.verify-identifier',
+  ];
+
+  private readonly cache = new Map<string, CacheEntry>();
+
+  constructor(
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => SettingService))
+    private readonly setting: SettingService,
+  ) {}
+
+  /**
+   * `viaConnector` marca a chamada como vinda de um cliente OAuth externo.
+   *
+   * Um token de conector herda os papeis INTEIROS de quem autorizou — para um
+   * admin, todas as tools do sistema ao alcance de um prompt. Como o conteudo
+   * que o agente le pode vir de fora (um documento, um chamado, um e-mail), o
+   * papel sozinho nao e uma fronteira suficiente: e preciso um teto que valha
+   * mesmo para quem pode tudo.
+   *
+   * A negativa NAO se aplica ao caminho interno (chave `hedhog_mcp_`, JWT de
+   * login, mcp-chat): ali quem chama e o proprio operador, com a tela na frente.
+   */
+  async getAllowedToolNames(
+    userId: number,
+    viaConnector = false,
+  ): Promise<Set<string>> {
+    // Sem usuário não há concessão. A guarda não é teórica: `user_id: undefined`
+    // faz o Prisma *descartar* o filtro, e `role_user: { some: {} }` casaria com
+    // qualquer rota ligada a qualquer papel — liberando tudo em vez de nada.
+    if (!userId) return new Set();
+
+    // A chave inclui a origem: o mesmo usuario tem conjuntos diferentes pelo
+    // conector e pelo caminho interno, e uma chave so por id serviria o conjunto
+    // errado para quem usa os dois.
+    const cacheKey = viaConnector ? `c:${userId}` : `i:${userId}`;
+
+    const cached = this.cache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) {
+      return cached.names;
+    }
+
+    const rows = await this.prisma.route.findMany({
+      where: {
+        type: 'MCP' as any,
+        tool_name: { not: null },
+        role_route: {
+          some: {
+            role: {
+              role_user: {
+                some: { user_id: userId },
+              },
+            },
+          },
+        },
+      },
+      select: { tool_name: true },
+    });
+
+    const names = new Set(
+      rows
+        .map((row) => row.tool_name)
+        .filter((name): name is string => Boolean(name)),
+    );
+
+    if (viaConnector) {
+      for (const denied of await this.getDeniedTools()) {
+        names.delete(denied);
+      }
+    }
+
+    this.remember(cacheKey, names);
+
+    return names;
+  }
+
+  async canCall(
+    userId: number,
+    toolName: string,
+    viaConnector = false,
+  ): Promise<boolean> {
+    const allowed = await this.getAllowedToolNames(userId, viaConnector);
+    return allowed.has(toolName);
+  }
+
+  /**
+   * A lista vem de setting, e nao de constante, porque a fronteira do que um
+   * agente externo pode fazer muda com o uso — e mudar isso nao deve exigir
+   * deploy. O `getSettingValues` ja e cacheado por versao, entao ler aqui e
+   * barato.
+   *
+   * Falha de leitura NAO abre a porta: sem conseguir a lista, o servico assume
+   * o padrao embutido. Uma setting apagada por engano nao pode virar permissao.
+   */
+  private async getDeniedTools(): Promise<string[]> {
+    try {
+      const values = await this.setting.getSettingValues([DENIED_TOOLS_SETTING]);
+      const raw = values[DENIED_TOOLS_SETTING];
+      const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw;
+
+      if (Array.isArray(parsed) && parsed.length > 0) {
+        return parsed.map((t) => String(t));
+      }
+    } catch {
+      // cai no padrao abaixo
+    }
+
+    return McpPermissionService.DEFAULT_DENIED_TOOLS;
+  }
+
+  private remember(cacheKey: string, names: Set<string>): void {
+    if (this.cache.size >= McpPermissionService.CACHE_MAX_ENTRIES) {
+      const now = Date.now();
+      for (const [key, entry] of this.cache) {
+        if (entry.expiresAt <= now) this.cache.delete(key);
+      }
+      // Todas ainda válidas: o cache inteiro sai. Esvaziar custa uma consulta
+      // por usuário ativo; deixar crescer sem teto custa memória para sempre.
+      if (this.cache.size >= McpPermissionService.CACHE_MAX_ENTRIES) {
+        this.cache.clear();
+      }
+    }
+
+    this.cache.set(cacheKey, {
+      expiresAt: Date.now() + McpPermissionService.CACHE_TTL_MS,
+      names,
+    });
+  }
+}

package/src/mcp/mcp-server.service.spec.ts

@@ -32,11 +32,19 @@ const makeDeps = () => {
   const audit = {
     record: jest.fn<any>().mockResolvedValue(undefined),
   };
-  return { registry, audit };
+  const permissions = {
+    getAllowedToolNames: jest.fn<any>().mockResolvedValue(new Set<string>()),
+    canCall: jest.fn<any>().mockResolvedValue(true),
+  };
+  return { registry, audit, permissions };
 };
 
 const makeService = (deps = makeDeps()) => ({
-  service: new McpServerService(deps.registry as any, deps.audit as any),
+  service: new McpServerService(
+    deps.registry as any,
+    deps.audit as any,
+    deps.permissions as any,
+  ),
   deps,
 });
 
@@ -50,14 +58,21 @@ const context: McpContext = {
   sessionId: 'sess-1',
   locale: 'pt-BR',
   toolName: '',
+  clientId: null,
 };
 
+/** Mesmo usuario, mas a chamada vem de um cliente OAuth externo. */
+const connectorContext: McpContext = { ...context, clientId: 'claude-connector' };
+
 describe('McpServerService', () => {
   afterEach(() => jest.clearAllMocks());
 
   describe('buildServer / ListTools handler', () => {
     it('lista as ferramentas registradas mapeando definition para o schema MCP', async () => {
       const { service, deps } = makeService();
+      deps.permissions.getAllowedToolNames.mockResolvedValue(
+        new Set(['tool-a', 'tool-b']),
+      );
       deps.registry.getAll.mockReturnValue([
         {
           definition: { name: 'tool-a', description: 'desc a', inputSchema: { type: 'object', properties: { x: {} } } },
@@ -77,6 +92,55 @@ describe('McpServerService', () => {
         { name: 'tool-a', description: 'desc a', inputSchema: { type: 'object', properties: { x: {} } } },
         { name: 'tool-b', description: 'desc b', inputSchema: { type: 'object', properties: {} } },
       ]);
+      expect(deps.permissions.getAllowedToolNames).toHaveBeenCalledWith(
+        context.userId,
+        false,
+      );
+    });
+
+    it('omite da lista as ferramentas que o usuário não pode chamar', async () => {
+      const { service, deps } = makeService();
+      deps.permissions.getAllowedToolNames.mockResolvedValue(new Set(['tool-a']));
+      deps.registry.getAll.mockReturnValue([
+        { definition: { name: 'tool-a', description: 'desc a' }, handler: jest.fn() },
+        { definition: { name: 'tool-b', description: 'desc b' }, handler: jest.fn() },
+      ]);
+
+      (service as any).buildServer(context);
+      const listHandler = getRegisteredHandler(ListToolsRequestSchema);
+      const result = await listHandler();
+
+      expect(result.tools.map((t: any) => t.name)).toEqual(['tool-a']);
+    });
+
+    it('sinaliza a origem para o filtro quando a chamada vem de um conector', async () => {
+      const { service, deps } = makeService();
+      deps.permissions.getAllowedToolNames.mockResolvedValue(new Set(['tool-a']));
+      deps.registry.getAll.mockReturnValue([
+        { definition: { name: 'tool-a', description: 'desc a' }, handler: jest.fn() },
+      ]);
+
+      (service as any).buildServer(connectorContext);
+      const listHandler = getRegisteredHandler(ListToolsRequestSchema);
+      await listHandler();
+
+      expect(deps.permissions.getAllowedToolNames).toHaveBeenCalledWith(
+        connectorContext.userId,
+        true,
+      );
+    });
+
+    it('devolve lista vazia quando o usuário não tem nenhuma tool concedida', async () => {
+      const { service, deps } = makeService();
+      deps.permissions.getAllowedToolNames.mockResolvedValue(new Set<string>());
+      deps.registry.getAll.mockReturnValue([
+        { definition: { name: 'tool-a', description: 'desc a' }, handler: jest.fn() },
+      ]);
+
+      (service as any).buildServer(context);
+      const listHandler = getRegisteredHandler(ListToolsRequestSchema);
+
+      await expect(listHandler()).resolves.toEqual({ tools: [] });
     });
   });
 
@@ -123,6 +187,7 @@ describe('McpServerService', () => {
       expect(deps.audit.record).toHaveBeenCalledWith(
         expect.objectContaining({
           userId: context.userId,
+          clientId: null,
           toolName: 'tool-a',
           input: { a: 1 },
           success: true,
@@ -144,6 +209,23 @@ describe('McpServerService', () => {
       expect(handler).toHaveBeenCalledWith({}, expect.anything());
     });
 
+    // A auditoria precisa responder "quem pediu isso": sem o client, uma acao
+    // feita pelo Claude Desktop e indistinguivel de uma feita pelo Claude Code.
+    it('registra na auditoria o client que originou a chamada', async () => {
+      const { service, deps } = makeService();
+      const handler = jest.fn<any>().mockResolvedValue({});
+      deps.registry.getAll.mockReturnValue([]);
+      deps.registry.get.mockReturnValue({ definition: { name: 'tool-a' }, handler });
+
+      (service as any).buildServer(connectorContext);
+      const callHandler = getRegisteredHandler(CallToolRequestSchema);
+      await callHandler({ params: { name: 'tool-a', arguments: {} } });
+
+      expect(deps.audit.record).toHaveBeenCalledWith(
+        expect.objectContaining({ clientId: 'claude-connector' }),
+      );
+    });
+
     it('captura exceção do handler, audita success:false com o erro e retorna isError', async () => {
       const { service, deps } = makeService();
       const handler = jest.fn<any>().mockRejectedValue(new Error('boom'));