Clipador: subpáginas, jogos, idioma por canal e juiz com Gemini e IA reserva
- Clipador em subpáginas (Cortes, Sessões, Fontes, Jogos, Ajustes) com moldura comum, lista + diálogo dos cortes e submenu na barra lateral. - Perfis de jogo (o que a IA sabe de cada jogo), parar pausa o monitor e idioma por fonte e por canal de publicação (migração v9: accounts.language). - Juiz: Gemini CLI como terceiro provedor e IA reserva por chamada — se a IA escolhida cair por cota, login, chave ou rede, a próxima da ordem de Configurações → IA responde (com pausa da que caiu). Lê data/ai/settings.json e o cofre data/ai/vault.bin (DPAPI) escritos pelo painel; contrato em doc/ia.md. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,232 @@
|
||||
"""Configuração das IAs (Claude, Codex, Gemini) compartilhada com o painel — contrato em `doc/ia.md`.
|
||||
|
||||
O painel (Configurações → IA) escreve dois arquivos em `data/ai/`; o Clipador só LÊ:
|
||||
- `settings.json` (sem segredo): quais IAs estão ligadas, modo de login (`oauth`/`apiKey`), ordem da reserva e
|
||||
pausa depois de uma falha de indisponibilidade. Relido quando o `mtime` muda; ausente/inválido = padrão.
|
||||
- `vault.bin`: as chaves de API, JSON cifrado com a DPAPI do Windows (usuário atual, entropia própria).
|
||||
|
||||
Daqui sai o ambiente (`env`) de cada chamada de CLI: no modo chave, a variável da chave só vale para a chamada;
|
||||
no modo login, a variável é removida para a CLI usar a sessão já logada. O login global de cada CLI não muda.
|
||||
|
||||
Nos testes, a pasta e o cifrador são injetados (`AiConfig(folder, cipher=...)`); a DPAPI real só existe no Windows.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
import threading
|
||||
from pathlib import Path
|
||||
from typing import Protocol
|
||||
|
||||
from .config import REPO_ROOT
|
||||
|
||||
log = logging.getLogger("cenaforge_clipper.ai_settings")
|
||||
|
||||
AI_PROVIDERS = ("claude", "codex", "gemini")
|
||||
# Pasta padrão dos arquivos do painel. Os testes trocam (conftest) para não ler o data/ai real.
|
||||
DEFAULT_AI_DIR = REPO_ROOT / "data" / "ai"
|
||||
AUTH_MODES = ("oauth", "apiKey")
|
||||
DEFAULT_COOLDOWN_MIN = 15.0
|
||||
DEFAULT_SETTINGS: dict = {
|
||||
"version": 1,
|
||||
"providers": {
|
||||
"claude": {"enabled": True, "authMode": "oauth"},
|
||||
"codex": {"enabled": True, "authMode": "oauth"},
|
||||
"gemini": {"enabled": False, "authMode": "apiKey"},
|
||||
},
|
||||
"order": ["claude", "codex", "gemini"],
|
||||
"fallback": {"enabled": True, "cooldownMin": DEFAULT_COOLDOWN_MIN},
|
||||
}
|
||||
# Variável de ambiente da chave de API de cada CLI (tabela "Ambiente de cada chamada" do doc/ia.md).
|
||||
API_KEY_ENV = {"claude": "ANTHROPIC_API_KEY", "codex": "CODEX_API_KEY", "gemini": "GEMINI_API_KEY"}
|
||||
GEMINI_OAUTH_ENV = "GOOGLE_GENAI_USE_GCA"
|
||||
|
||||
# Entropia do cofre de IA (a mesma que o painel usa ao cifrar). Não é senha: só separa este cofre dos outros.
|
||||
_VAULT_ENTROPY = b"CenaForge.AI.vault.v1"
|
||||
|
||||
|
||||
class AiVaultError(RuntimeError):
|
||||
"""O cofre de IA não abriu (outro usuário/máquina, corrompido, ou DPAPI indisponível)."""
|
||||
|
||||
|
||||
class Cipher(Protocol):
|
||||
def unprotect(self, data: bytes) -> bytes: ...
|
||||
|
||||
|
||||
class DpapiCipher:
|
||||
"""DPAPI via ctypes (crypt32.dll), só a decifragem — quem cifra é o painel. Mesmo padrão de
|
||||
`publisher/app/vault.py` (pacotes separados: o código é copiado, não importado)."""
|
||||
|
||||
CRYPTPROTECT_UI_FORBIDDEN = 0x01
|
||||
|
||||
def __init__(self, entropy: bytes = _VAULT_ENTROPY) -> None:
|
||||
if sys.platform != "win32":
|
||||
raise AiVaultError("O cofre de IA usa a DPAPI do Windows; este sistema não tem.")
|
||||
import ctypes
|
||||
from ctypes import wintypes
|
||||
|
||||
class DataBlob(ctypes.Structure):
|
||||
_fields_ = [("cbData", wintypes.DWORD), ("pbData", ctypes.POINTER(ctypes.c_char))]
|
||||
|
||||
self._entropy = entropy
|
||||
self._ctypes = ctypes
|
||||
self._blob = DataBlob
|
||||
self._crypt32 = ctypes.WinDLL("crypt32", use_last_error=True)
|
||||
self._kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
|
||||
self._kernel32.LocalFree.argtypes = [ctypes.c_void_p]
|
||||
self._kernel32.LocalFree.restype = ctypes.c_void_p
|
||||
fn = self._crypt32.CryptUnprotectData
|
||||
fn.argtypes = [ctypes.POINTER(DataBlob), ctypes.c_void_p, ctypes.POINTER(DataBlob), ctypes.c_void_p,
|
||||
ctypes.c_void_p, wintypes.DWORD, ctypes.POINTER(DataBlob)]
|
||||
fn.restype = wintypes.BOOL
|
||||
|
||||
def _to_blob(self, data: bytes):
|
||||
buffer = self._ctypes.create_string_buffer(data, len(data))
|
||||
blob = self._blob(len(data), self._ctypes.cast(buffer, self._ctypes.POINTER(self._ctypes.c_char)))
|
||||
return blob, buffer # o buffer precisa continuar vivo enquanto o blob for usado
|
||||
|
||||
def unprotect(self, data: bytes) -> bytes:
|
||||
ctypes = self._ctypes
|
||||
in_blob, _keep_in = self._to_blob(data)
|
||||
entropy, _keep_entropy = self._to_blob(self._entropy)
|
||||
out_blob = self._blob()
|
||||
ok = self._crypt32.CryptUnprotectData(ctypes.byref(in_blob), None, ctypes.byref(entropy), None, None,
|
||||
self.CRYPTPROTECT_UI_FORBIDDEN, ctypes.byref(out_blob))
|
||||
if not ok:
|
||||
raise AiVaultError(f"A DPAPI do Windows não conseguiu abrir o cofre de IA (erro {ctypes.get_last_error()}). "
|
||||
"O arquivo pode ser de outro usuário ou de outro computador.")
|
||||
try:
|
||||
return ctypes.string_at(out_blob.pbData, out_blob.cbData)
|
||||
finally:
|
||||
self._kernel32.LocalFree(out_blob.pbData)
|
||||
|
||||
|
||||
def normalize_settings(raw: object) -> dict:
|
||||
"""Valida o settings.json do painel campo a campo. O que faltar ou vier errado fica no padrão do doc."""
|
||||
settings = copy.deepcopy(DEFAULT_SETTINGS)
|
||||
if not isinstance(raw, dict):
|
||||
return settings
|
||||
providers = raw.get("providers")
|
||||
if isinstance(providers, dict):
|
||||
for name in AI_PROVIDERS:
|
||||
item = providers.get(name)
|
||||
if not isinstance(item, dict):
|
||||
continue
|
||||
if isinstance(item.get("enabled"), bool):
|
||||
settings["providers"][name]["enabled"] = item["enabled"]
|
||||
if item.get("authMode") in AUTH_MODES:
|
||||
settings["providers"][name]["authMode"] = item["authMode"]
|
||||
order = raw.get("order")
|
||||
if isinstance(order, list):
|
||||
known = [p for p in dict.fromkeys(order) if p in AI_PROVIDERS]
|
||||
# Quem ficou de fora da lista vai para o fim, na ordem padrão (a lista sempre tem as três).
|
||||
settings["order"] = known + [p for p in AI_PROVIDERS if p not in known]
|
||||
fallback = raw.get("fallback")
|
||||
if isinstance(fallback, dict):
|
||||
if isinstance(fallback.get("enabled"), bool):
|
||||
settings["fallback"]["enabled"] = fallback["enabled"]
|
||||
cooldown = fallback.get("cooldownMin")
|
||||
if isinstance(cooldown, (int, float)) and not isinstance(cooldown, bool) and cooldown >= 0:
|
||||
settings["fallback"]["cooldownMin"] = float(cooldown)
|
||||
return settings
|
||||
|
||||
|
||||
def _mtime(path: Path) -> int | None:
|
||||
try:
|
||||
return path.stat().st_mtime_ns
|
||||
except OSError:
|
||||
return None
|
||||
|
||||
|
||||
class AiConfig:
|
||||
"""Leitura (com cache por mtime) do settings.json e do vault.bin do painel."""
|
||||
|
||||
def __init__(self, folder: Path | None = None, cipher: Cipher | None = None,
|
||||
environ: dict[str, str] | None = None):
|
||||
self.folder = Path(folder) if folder is not None else DEFAULT_AI_DIR
|
||||
self._cipher = cipher
|
||||
self._environ = environ # None = os.environ do momento da chamada
|
||||
self._lock = threading.RLock()
|
||||
self._settings_cache: tuple[int | None, dict] | None = None
|
||||
self._keys_cache: tuple[int | None, dict[str, str]] | None = None
|
||||
self.vault_error: str | None = None
|
||||
|
||||
@property
|
||||
def settings_path(self) -> Path:
|
||||
return self.folder / "settings.json"
|
||||
|
||||
@property
|
||||
def vault_path(self) -> Path:
|
||||
return self.folder / "vault.bin"
|
||||
|
||||
def settings(self) -> dict:
|
||||
"""Configuração atual (cópia). Relê o arquivo só quando o mtime muda."""
|
||||
with self._lock:
|
||||
stamp = _mtime(self.settings_path)
|
||||
if self._settings_cache is None or self._settings_cache[0] != stamp:
|
||||
raw: object = None
|
||||
if stamp is not None:
|
||||
try:
|
||||
raw = json.loads(self.settings_path.read_text(encoding="utf-8"))
|
||||
except (OSError, ValueError) as exc:
|
||||
log.warning("data/ai/settings.json inválido (%s); usando o padrão", exc)
|
||||
self._settings_cache = (stamp, normalize_settings(raw))
|
||||
return copy.deepcopy(self._settings_cache[1])
|
||||
|
||||
def provider(self, name: str) -> dict:
|
||||
return self.settings()["providers"].get(name, {"enabled": False, "authMode": "oauth"})
|
||||
|
||||
def api_keys(self) -> dict[str, str]:
|
||||
"""Chaves do cofre (só as que existem). Cofre ausente = {}; cofre que não abre = {} e `vault_error`."""
|
||||
with self._lock:
|
||||
stamp = _mtime(self.vault_path)
|
||||
if self._keys_cache is None or self._keys_cache[0] != stamp:
|
||||
self._keys_cache = (stamp, self._read_vault() if stamp is not None else {})
|
||||
if stamp is None:
|
||||
self.vault_error = None
|
||||
return dict(self._keys_cache[1])
|
||||
|
||||
def _read_vault(self) -> dict[str, str]:
|
||||
try:
|
||||
raw = self.vault_path.read_bytes()
|
||||
if not raw:
|
||||
self.vault_error = None
|
||||
return {}
|
||||
cipher = self._cipher or DpapiCipher()
|
||||
data = json.loads(cipher.unprotect(raw).decode("utf-8"))
|
||||
except Exception as exc: # noqa: BLE001 - cofre ilegível não derruba o juiz: segue sem chaves
|
||||
self.vault_error = str(exc)[:200] or "cofre de IA ilegível"
|
||||
log.warning("não abri data/ai/vault.bin: %s", self.vault_error)
|
||||
return {}
|
||||
self.vault_error = None
|
||||
if not isinstance(data, dict):
|
||||
return {}
|
||||
return {k: v.strip() for k, v in data.items() if k in AI_PROVIDERS and isinstance(v, str) and v.strip()}
|
||||
|
||||
def has_key(self, provider: str) -> bool:
|
||||
return bool(self.api_keys().get(provider))
|
||||
|
||||
def provider_env(self, provider: str) -> dict[str, str]:
|
||||
"""Ambiente da chamada da CLI de `provider`, conforme o modo de login (tabela do doc/ia.md)."""
|
||||
env = dict(os.environ if self._environ is None else self._environ)
|
||||
key_var = API_KEY_ENV.get(provider)
|
||||
if not key_var:
|
||||
return env
|
||||
mode = self.provider(provider).get("authMode", "oauth")
|
||||
if mode == "apiKey":
|
||||
key = self.api_keys().get(provider)
|
||||
if key:
|
||||
env[key_var] = key
|
||||
else:
|
||||
env.pop(key_var, None)
|
||||
if provider == "gemini":
|
||||
env.pop(GEMINI_OAUTH_ENV, None)
|
||||
else:
|
||||
env.pop(key_var, None)
|
||||
if provider == "gemini":
|
||||
env[GEMINI_OAUTH_ENV] = "true"
|
||||
return env
|
||||
Reference in New Issue
Block a user