@hed-hog/core 0.0.399 → 0.0.401

package/src/mcp/guards/mcp-permission.guard.spec.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { afterEach, describe, expect, it, jest } from '@jest/globals';
 import { ForbiddenException } from '@nestjs/common';
 import { McpPermissionGuard } from './mcp-permission.guard';
 
@@ -6,9 +6,11 @@ const makeContext = (request: any) => ({
   switchToHttp: () => ({ getRequest: () => request }),
 });
 
-const makeService = () => {
-  const prisma = { route: { count: jest.fn() } };
-  return { guard: new McpPermissionGuard(prisma as any), prisma };
+const makeService = (allowed: string[] = []) => {
+  const permissions = {
+    getAllowedToolNames: jest.fn<any>().mockResolvedValue(new Set(allowed)),
+  };
+  return { guard: new McpPermissionGuard(permissions as any), permissions };
 };
 
 describe('McpPermissionGuard', () => {
@@ -22,18 +24,17 @@ describe('McpPermissionGuard', () => {
   });
 
   it('permite POST sem tools/call (ex.: tools/list)', async () => {
-    const { guard, prisma } = makeService();
+    const { guard, permissions } = makeService();
     await expect(
       guard.canActivate(
         makeContext({ method: 'POST', body: { method: 'tools/list' } }) as any,
       ),
     ).resolves.toBe(true);
-    expect(prisma.route.count).not.toHaveBeenCalled();
+    expect(permissions.getAllowedToolNames).not.toHaveBeenCalled();
   });
 
   it('permite tools/call quando usuário tem permissão', async () => {
-    const { guard, prisma } = makeService();
-    prisma.route.count.mockResolvedValue(1);
+    const { guard, permissions } = makeService(['my_tool']);
     const request = {
       method: 'POST',
       body: { method: 'tools/call', params: { name: 'my_tool' } },
@@ -42,16 +43,11 @@ describe('McpPermissionGuard', () => {
     await expect(guard.canActivate(makeContext(request) as any)).resolves.toBe(
       true,
     );
-    expect(prisma.route.count).toHaveBeenCalledWith(
-      expect.objectContaining({
-        where: expect.objectContaining({ tool_name: 'my_tool' }),
-      }),
-    );
+    expect(permissions.getAllowedToolNames).toHaveBeenCalledWith(2, false);
   });
 
   it('nega tools/call sem permissão', async () => {
-    const { guard, prisma } = makeService();
-    prisma.route.count.mockResolvedValue(0);
+    const { guard } = makeService([]);
     const request = {
       method: 'POST',
       body: { method: 'tools/call', params: { name: 'secret_tool' } },
@@ -61,4 +57,102 @@ describe('McpPermissionGuard', () => {
       ForbiddenException,
     );
   });
+
+  /**
+   * O teto so vale para cliente OAuth externo. O token interno (chave
+   * hedhog_mcp_, JWT de login) nao tem `aud`, e ali quem chama e o proprio
+   * operador, com a tela na frente.
+   */
+  describe('origem da chamada', () => {
+    it('marca como conector quando o token tem aud', async () => {
+      const { guard, permissions } = makeService(['my_tool']);
+      const request = {
+        method: 'POST',
+        body: { method: 'tools/call', params: { name: 'my_tool' } },
+        auth: { sub: 2, aud: 'https://hub-api.example.com/mcp' },
+      };
+      await guard.canActivate(makeContext(request) as any);
+      expect(permissions.getAllowedToolNames).toHaveBeenCalledWith(2, true);
+    });
+
+    it('nao marca como conector sem aud', async () => {
+      const { guard, permissions } = makeService(['my_tool']);
+      const request = {
+        method: 'POST',
+        body: { method: 'tools/call', params: { name: 'my_tool' } },
+        auth: { sub: 2 },
+      };
+      await guard.canActivate(makeContext(request) as any);
+      expect(permissions.getAllowedToolNames).toHaveBeenCalledWith(2, false);
+    });
+  });
+
+  /**
+   * REGRESSAO: o transporte do SDK aceita batch JSON-RPC (corpo array) e despacha
+   * cada mensagem para o mesmo handler. Lendo so `body.method`, um `tools/call`
+   * envolvido em colchetes fazia `toolName` virar undefined, o guard liberava, e
+   * o handler executava a tool sem checar papel nenhum — bypass completo da
+   * autorizacao, reproduzido com o SDK instalado.
+   */
+  describe('batch JSON-RPC (corpo array)', () => {
+    it('nega tool sem permissão dentro de um lote', async () => {
+      const { guard } = makeService(['permitida']);
+      const request = {
+        method: 'POST',
+        body: [
+          { jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: 'proibida' } },
+        ],
+        auth: { sub: 2 },
+      };
+      await expect(
+        guard.canActivate(makeContext(request) as any),
+      ).rejects.toThrow(ForbiddenException);
+    });
+
+    it('nega o lote inteiro se UMA das mensagens não é permitida', async () => {
+      const { guard } = makeService(['permitida']);
+      const request = {
+        method: 'POST',
+        body: [
+          { method: 'tools/call', params: { name: 'permitida' } },
+          { method: 'tools/list' },
+          { method: 'tools/call', params: { name: 'proibida' } },
+        ],
+        auth: { sub: 2 },
+      };
+      await expect(
+        guard.canActivate(makeContext(request) as any),
+      ).rejects.toThrow(/proibida/);
+    });
+
+    it('permite lote em que toda tool é concedida', async () => {
+      const { guard, permissions } = makeService(['a', 'b']);
+      const request = {
+        method: 'POST',
+        body: [
+          { method: 'tools/call', params: { name: 'a' } },
+          { method: 'tools/call', params: { name: 'b' } },
+        ],
+        auth: { sub: 2 },
+      };
+      await expect(guard.canActivate(makeContext(request) as any)).resolves.toBe(
+        true,
+      );
+      // Uma consulta so para o lote inteiro.
+      expect(permissions.getAllowedToolNames).toHaveBeenCalledTimes(1);
+    });
+
+    it('lote sem nenhum tools/call passa sem consultar permissão', async () => {
+      const { guard, permissions } = makeService();
+      const request = {
+        method: 'POST',
+        body: [{ method: 'initialize' }, { method: 'tools/list' }],
+        auth: { sub: 2 },
+      };
+      await expect(guard.canActivate(makeContext(request) as any)).resolves.toBe(
+        true,
+      );
+      expect(permissions.getAllowedToolNames).not.toHaveBeenCalled();
+    });
+  });
 });

package/src/mcp/guards/mcp-permission.guard.ts

@@ -1,51 +1,76 @@
-import { PrismaService } from '@hed-hog/api-prisma';
-import {
-  CanActivate,
-  ExecutionContext,
-  ForbiddenException,
-  Injectable,
-} from '@nestjs/common';
-import { Request } from 'express';
-
-@Injectable()
-export class McpPermissionGuard implements CanActivate {
-  constructor(private readonly prisma: PrismaService) {}
-
-  async canActivate(context: ExecutionContext): Promise<boolean> {
-    const request = context.switchToHttp().getRequest<Request>();
-
-    // Only POST requests carry tool invocations
-    if (request.method !== 'POST') return true;
-
-    const body = request.body as any;
-    const toolName: string | undefined =
-      body?.method === 'tools/call' ? body?.params?.name : undefined;
-
-    // tools/list, initialize, ping, etc. — no per-tool permission check needed
-    if (!toolName) return true;
-
-    const userId = (request as any)?.auth?.sub;
-
-    const count = await this.prisma.route.count({
-      where: {
-        type: 'MCP' as any,
-        tool_name: toolName,
-        role_route: {
-          some: {
-            role: {
-              role_user: {
-                some: { user_id: userId },
-              },
-            },
-          },
-        },
-      },
-    });
-
-    if (count === 0) {
-      throw new ForbiddenException(`Access denied to MCP tool '${toolName}'`);
-    }
-
-    return true;
-  }
-}
+import {
+  CanActivate,
+  ExecutionContext,
+  ForbiddenException,
+  Injectable,
+} from '@nestjs/common';
+import { Request } from 'express';
+import { McpPermissionService } from '../mcp-permission.service';
+
+/**
+ * A trava de verdade do `tools/call`.
+ *
+ * O `tools/list` também filtra pelas mesmas permissões, mas aquilo é
+ * apresentação: nada impede um cliente de chamar uma tool que ele nunca viu na
+ * lista. Por isso os dois consultam o mesmo `McpPermissionService` e este guard
+ * continua existindo.
+ *
+ * O corpo pode ser UM objeto JSON-RPC ou um ARRAY deles — o transporte do SDK
+ * aceita batch (`if (Array.isArray(rawMessage))`) e despacha cada mensagem para o
+ * mesmo handler. Ler só `body.method` deixava passar qualquer chamada envolvida em
+ * colchetes: `body.method` fica `undefined`, o guard liberava, e o handler de
+ * `CallToolRequestSchema` executa sem olhar papel nenhum. Toda mensagem do lote
+ * precisa ser inspecionada.
+ */
+@Injectable()
+export class McpPermissionGuard implements CanActivate {
+  constructor(private readonly permissions: McpPermissionService) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest<Request>();
+
+    // Only POST requests carry tool invocations
+    if (request.method !== 'POST') return true;
+
+    const toolNames = this.extractToolNames(request.body);
+
+    // tools/list, initialize, ping, etc. — no per-tool permission check needed
+    if (toolNames.length === 0) return true;
+
+    const auth = (request as any)?.auth;
+    const userId = auth?.sub;
+    // Token de cliente OAuth externo carrega `aud`; o interno, nao. O teto de
+    // permissao so vale para o primeiro.
+    const viaConnector = auth?.aud !== undefined;
+
+    // Uma consulta só: o service resolve o conjunto inteiro de uma vez e o cache
+    // atende as demais mensagens do lote.
+    const allowed = await this.permissions.getAllowedToolNames(
+      userId,
+      viaConnector,
+    );
+
+    for (const toolName of toolNames) {
+      if (!allowed.has(toolName)) {
+        throw new ForbiddenException(`Access denied to MCP tool '${toolName}'`);
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Nomes de tool de toda mensagem `tools/call` do corpo, seja ele um objeto ou
+   * um lote. Mensagem malformada é ignorada aqui de propósito — quem a rejeita é
+   * o parser do SDK, e inventar um nome a partir dela só produziria um 403 com
+   * mensagem enganosa.
+   */
+  private extractToolNames(body: unknown): string[] {
+    const messages = Array.isArray(body) ? body : [body];
+
+    return messages
+      .filter((m: any) => m?.method === 'tools/call')
+      .map((m: any) => m?.params?.name)
+      .filter((name: unknown): name is string => typeof name === 'string' && name.length > 0);
+  }
+}

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

@@ -0,0 +1,107 @@
+import { describe, expect, it, jest } from '@jest/globals';
+
+jest.mock('@hed-hog/api-prisma', () => ({
+  __esModule: true,
+  PrismaService: class {},
+  Prisma: {},
+}));
+
+import { McpAuditService } from './mcp-audit.service';
+
+const makeService = () => {
+  const rows: any[] = [];
+
+  const prisma: any = {
+    mcp_tool_call_log: {
+      create: jest.fn(async ({ data }: any) => {
+        rows.push(data);
+        return data;
+      }),
+    },
+  };
+
+  const accessLogService: any = { recordMcp: jest.fn() };
+  const service = new McpAuditService(prisma, accessLogService);
+
+  return { service, rows, accessLogService };
+};
+
+const base = {
+  userId: 7,
+  toolName: 'finance.titles.attachments.add',
+  success: true,
+  durationMs: 12,
+};
+
+describe('McpAuditService.record', () => {
+  it('redige o conteúdo do arquivo e preserva o resto dos argumentos', async () => {
+    const { service, rows } = makeService();
+    const base64 = 'A'.repeat(50_000);
+
+    await service.record({
+      ...base,
+      input: { titleId: 42, fileName: 'nota.pdf', fileBase64: base64 },
+    });
+
+    const logged = JSON.parse(rows[0].input);
+
+    // O que a auditoria quer é o id do título e a modalidade, não mil caracteres de
+    // base64 — que é tudo o que sobrava do slice(0, 1000).
+    expect(logged.titleId).toBe(42);
+    expect(logged.fileName).toBe('nota.pdf');
+    expect(logged.fileBase64).toBe('<redacted: 50000 chars>');
+    expect(rows[0].input).not.toContain('AAAA');
+  });
+
+  it('redige também a parte do upload em partes', async () => {
+    const { service, rows } = makeService();
+
+    await service.record({
+      ...base,
+      toolName: 'core.files.upload.append',
+      input: { uploadId: 3, index: 0, chunkBase64: 'B'.repeat(1000) },
+    });
+
+    const logged = JSON.parse(rows[0].input);
+    expect(logged.uploadId).toBe(3);
+    expect(logged.chunkBase64).toBe('<redacted: 1000 chars>');
+  });
+
+  it('mantém a entrada intacta quando não há conteúdo de arquivo', async () => {
+    const { service, rows } = makeService();
+
+    await service.record({ ...base, input: { titleId: 42, fileId: 10 } });
+
+    expect(JSON.parse(rows[0].input)).toEqual({ titleId: 42, fileId: 10 });
+  });
+
+  it('não modifica o objeto de entrada do chamador', async () => {
+    // O mesmo objeto segue para o handler da tool; redigir no lugar apagaria o arquivo.
+    const { service } = makeService();
+    const input = { fileBase64: 'AAAA' };
+
+    await service.record({ ...base, input });
+
+    expect(input.fileBase64).toBe('AAAA');
+  });
+
+  it('continua cortando em 1000 caracteres o que sobra', async () => {
+    const { service, rows } = makeService();
+
+    await service.record({ ...base, input: { note: 'x'.repeat(5000) } });
+
+    expect(rows[0].input.length).toBe(1000);
+  });
+
+  it('não deixa a falha da auditoria derrubar a chamada', async () => {
+    const { service, rows } = makeService();
+    (service as any).prisma.mcp_tool_call_log.create.mockRejectedValue(
+      new Error('banco fora'),
+    );
+
+    await expect(
+      service.record({ ...base, input: { titleId: 1 } }),
+    ).resolves.toBeUndefined();
+    expect(rows).toHaveLength(0);
+  });
+});

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);
+      }
+    });
+  });
+
+});