Reestrutura para API multi-cliente com payload cifrado

A API deixa de ser especifica da Scardua e passa a atender varios
clientes pela rota /v1/holmes/{cliente}/...

Camada de clientes:
- app/clientes/base.py: ClienteBase (comportamento) + ClienteConfig (dado),
  separados de proposito — config sai do configs.json hoje e pode sair do
  banco amanha sem o resto mudar
- app/clientes/registry.py: resolve o {cliente} da rota pra instancia
- cada cliente traz a propria conta do Holmes; o cache de token virou um
  arquivo por cliente (antes era constante de modulo e dois clientes
  sobrescreveriam o token um do outro)

Holmes:
- funcoes de modulo viraram a classe HolmesAPI, amarrada a uma conta
- exposta pronta em cliente.holmes (cached_property)
- as funcoes de parsing puro (extrair_*) ficaram fora da classe

Config:
- app/schemas.py: modulo folha, so pydantic. Config e services usam os
  mesmos modelos sem um importar o outro
- app/config.py: so o carregamento do configs.json
- configs.json passa a ter "clientes": {"<nome>": {...}}

Compras:
- schemas aceitam o payload real do Holmes (PEDIDO_LINX vem como numero,
  NUMERO NF ENTRADA so existe depois da fase da nota)
- parcelas viram dict[int, Parcela], pareando parcelaN com o vencimento
  correspondente e pulando os slots vazios
- payload de saida carrega id_processo como chave de deduplicacao: o
  Holmes reentrega webhook e sem isso duplica linha no destino

Criptografia:
- app/services/cripto.py: envelope AES-256-GCM + RSA-OAEP-SHA256. RSA
  sozinho nao serve (cifra ~190 bytes; o payload passa disso)
- ciframos com a publica do conector e nao conseguimos desfazer

Deploy:
- Dockerfile e .dockerignore vieram da VPS pro repo
- docs/deploy.md: runbook, incluindo que --format docker e obrigatorio
  (em OCI o podman ignora o HEALTHCHECK silenciosamente)

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

app/clientes/base.py

@@ -1,55 +1,31 @@
 import os
 import tempfile
-from abc import ABC, abstractmethod
-from typing import Any
+from abc import ABC
+from functools import cached_property
 
-from fastapi import HTTPException
+from app.schemas import HolmesCliente
+from app.services.holmes import HolmesAPI
 from pydantic import BaseModel
 
 
-class HolmesCliente(BaseModel):
-    """Credenciais do Holmes. Cada cliente tem a propria conta de integracao."""
-
-    token_api: str
-    usuario: str
-    senha: str
-
-
 class ClienteConfig(BaseModel):
-    """
-    Os DADOS do cliente.
-
-    Fica separado da classe de proposito: dado da pra carregar do banco,
-    classe nao. No dia que cliente novo deixar de exigir deploy, e daqui
-    que a config vai sair — o resto do codigo nao muda.
-    """
-
     nome: str
     razao_social: str
     cnpj: str
     holmes: HolmesCliente
+    # Chave publica (PEM) da API do cliente. Ciframos com ela; so a privada,
+    # que fica com eles, abre.
+    chave_publica: str
 
 
 class ClienteBase(ABC):
-    """
-    Base de todo cliente atendido pela API.
+    # A subclasse atribui direto: config = ClienteConfig(...)
+    config: ClienteConfig
 
-    Regra de ouro: aqui so entra o que muda de COMPORTAMENTO entre clientes.
-    Valor (CNPJ, token, id de fluxo) vai em `config`, nao em atributo de classe
-    solto — senao a heranca vira dicionario com passos extras.
-
-    A subclasse satisfaz `config` e `modulos` como atributo de classe mesmo,
-    nao precisa escrever @property.
-    """
-
-    @property
-    @abstractmethod
-    def config(self) -> ClienteConfig: ...
-
-    @property
-    @abstractmethod
-    def modulos(self) -> dict[str, Any]:
-        """Processos habilitados: {"compras": ScarduaCompras(), ...}"""
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        if not hasattr(cls, "config"):
+            raise TypeError(f"{cls.__name__} precisa definir `config`")
 
     # --- comum a todos: ninguem sobrescreve ---
 
@@ -57,13 +33,18 @@ class ClienteBase(ABC):
     def nome(self) -> str:
         return self.config.nome
 
-    def modulo(self, nome: str) -> Any:
-        """Pega um processo habilitado do cliente, ou 404 se ele nao tem."""
-        if modulo := self.modulos.get(nome):
-            return modulo
-        raise HTTPException(
-            status_code=404,
-            detail=f"modulo '{nome}' nao habilitado para {self.nome}",
+    @cached_property
+    def holmes(self) -> HolmesAPI:
+        """
+        API do Holmes ja amarrada nas credenciais deste cliente.
+
+        cached_property e nao property: uma instancia por cliente, criada no
+        primeiro uso. Com @property comum sairia uma HolmesAPI nova a cada
+        acesso, e qualquer estado em memoria (token) se perderia.
+        """
+        return HolmesAPI(
+            credenciais=self.config.holmes,
+            cache_token=self.cache_token_holmes,
         )
 
     @property
@@ -71,8 +52,8 @@ class ClienteBase(ABC):
         """
         Arquivo de cache do token do Holmes, um por cliente.
 
-        Sem isso dois clientes com contas diferentes sobrescrevem o token
-        um do outro (ver _TOKEN_FILE em app/services/holmes.py).
+        Sem isso dois clientes com contas diferentes sobrescreveriam o token
+        um do outro — era o caso quando isso era uma constante de modulo.
         """
         return os.path.join(
             tempfile.gettempdir(), f"holmes_token_{self.nome}.json"