ragfly-cli 1.16.0__py3-none-any.whl

ragfly_cli/cloud_commands.py

@@ -0,0 +1,201 @@
+"""
+Comandos cloud — cliente HTTP contra la API REST de Railway.
+
+API pública:
+    obtener_token()          → str   (lee JWT o lanza RuntimeError)
+    cloud_get(path, **kw)    → dict  (GET autenticado)
+    cloud_post(path, **kw)   → dict  (POST autenticado)
+    CLOUD_URL                → str
+
+Clases auxiliares:
+    CloudError               — error de red/API con exit_code
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from . import keyring_store
+
+# ── Constantes ───────────────────────────────────────────────────────────────
+
+CLOUD_URL = "https://api.ragfly.ai"
+LEGACY_CREDENTIALS_PATH = Path.home() / ".ragfly" / "credentials.json"
+
+
+# ── Excepciones ───────────────────────────────────────────────────────────────
+
+class CloudError(Exception):
+    """Error de red o de la API cloud."""
+
+    def __init__(self, mensaje: str, exit_code: int = 2):
+        super().__init__(mensaje)
+        self.exit_code = exit_code
+
+
+# ── Auth ──────────────────────────────────────────────────────────────────────
+
+def _migrar_legacy_json_a_keyring() -> str | None:
+    """Si existe ~/.ragfly/credentials.json (v1.0.x), lo migra al keyring
+    del SO y lo borra. Retorna el token migrado, o None si no había."""
+    if not LEGACY_CREDENTIALS_PATH.exists():
+        return None
+    try:
+        creds = json.loads(LEGACY_CREDENTIALS_PATH.read_text())
+        token = creds.get("access_token", "")
+        email = creds.get("email", "")
+        if token:
+            keyring_store.guardar(token, email)
+        LEGACY_CREDENTIALS_PATH.unlink()
+        return token or None
+    except Exception:
+        return None
+
+
+def obtener_token() -> str:
+    """Resuelve el token de autenticación, en orden de precedencia:
+
+    1. ``RAGFLY_TOKEN`` del entorno — API key (``slm_live_...``) o JWT. Pensado
+       para CI/automatización headless, donde no hay keyring del SO.
+    2. El JWT guardado en el keyring del SO por ``ragfly login``.
+
+    La validez se delega al backend: cualquier 401 dispara logout en el shell.
+    """
+    env_token = os.environ.get("RAGFLY_TOKEN", "").strip()
+    if env_token:
+        return env_token
+    token = keyring_store.leer_token() or _migrar_legacy_json_a_keyring()
+    if not token:
+        raise CloudError(
+            "No has iniciado sesión. Ejecutá `ragfly login` o exportá RAGFLY_TOKEN.",
+            exit_code=1,
+        )
+    return token
+
+
+def guardar_credenciales(token: str, email: str, expires_in: int = 3600) -> None:
+    """Guarda JWT en el keyring del SO. `expires_in` se ignora (firma compat)."""
+    keyring_store.guardar(token, email)
+
+
+def borrar_credenciales() -> None:
+    """Borra JWT del keyring (logout). Limpia también el JSON legacy si quedó."""
+    keyring_store.borrar()
+    try:
+        if LEGACY_CREDENTIALS_PATH.exists():
+            LEGACY_CREDENTIALS_PATH.unlink()
+    except Exception:
+        pass
+
+
+def ya_esta_logueado() -> bool:
+    """True si hay token en el keyring (no valida vivo — eso lo hace /auth/me)."""
+    try:
+        obtener_token()
+        return True
+    except CloudError:
+        return False
+
+
+def cargar_contexto_actual() -> dict:
+    """Llama a /auth/me y retorna el contexto del usuario logueado."""
+    return cloud_get("/auth/me")
+
+
+# ── HTTP helpers ─────────────────────────────────────────────────────────────
+
+def _headers(token: str | None = None) -> dict[str, str]:
+    """Headers estándar para cualquier request al cloud.
+
+    Incluye X-Client-Version desde ragfly.__version__ — backend lo loggea
+    siempre y en el futuro puede rechazar versiones incompatibles (gated por
+    env ENFORCE_CLIENT_VERSION en backend).
+    """
+    from ragfly_cli import __version__ as _client_version
+
+    t = token or obtener_token()
+    return {
+        "Authorization": f"Bearer {t}",
+        "Content-Type": "application/json",
+        "X-Client-Version": _client_version,
+    }
+
+
+def cloud_get(
+    path: str,
+    params: dict | None = None,
+    token: str | None = None,
+    timeout: int = 30,
+) -> Any:
+    """GET autenticado contra CLOUD_URL/path. Retorna JSON parseado.
+
+    Wrapper retrocompatible sobre `CloudHttpClient` (ragfly.oop).
+    """
+    from ragfly_cli.oop import CloudHttpClient
+    return CloudHttpClient(timeout_get=timeout).get(path, params=params, token=token)
+
+
+def cloud_post(
+    path: str,
+    body: dict | None = None,
+    params: dict | None = None,
+    token: str | None = None,
+    timeout: int = 60,
+) -> Any:
+    """POST autenticado contra CLOUD_URL/path. Retorna JSON parseado.
+
+    Wrapper retrocompatible sobre `CloudHttpClient` (ragfly.oop).
+    """
+    from ragfly_cli.oop import CloudHttpClient
+    return CloudHttpClient(timeout_write=timeout).post(path, body=body, params=params, token=token)
+
+
+def _manejar_http_error(e: httpx.HTTPStatusError) -> None:
+    status = e.response.status_code
+    try:
+        detalle = e.response.json().get("detail", str(e))
+    except Exception:
+        detalle = e.response.text[:200] or str(e)
+
+    if status == 401:
+        raise CloudError("No autorizado. Ejecuta: ragfly login", exit_code=1)
+    if status == 403:
+        raise CloudError(f"Sin permisos: {detalle}", exit_code=1)
+    if status == 404:
+        raise CloudError(f"No encontrado: {detalle}", exit_code=1)
+    if status == 422:
+        raise CloudError(f"Datos inválidos: {detalle}", exit_code=1)
+    raise CloudError(f"Error {status}: {detalle}", exit_code=2)
+
+
+# ── Login helper ─────────────────────────────────────────────────────────────
+
+def login(email: str, password: str) -> dict:
+    """Autentica contra /auth/login y retorna el contexto del usuario."""
+    try:
+        r = httpx.post(
+            f"{CLOUD_URL}/auth/login",
+            json={"email": email, "password": password},
+            timeout=30,
+        )
+        r.raise_for_status()
+        data = r.json()
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code in (401, 403):
+            raise CloudError("Email o contraseña incorrectos.", exit_code=1)
+        _manejar_http_error(e)
+    except httpx.RequestError as e:
+        raise CloudError(f"No se pudo conectar al servidor: {e}", exit_code=2)
+
+    token = data.get("access_token") or data.get("token", "")
+    if not token:
+        raise CloudError("El servidor no retornó un token.", exit_code=2)
+
+    expires_in = data.get("expires_in", 3600)
+    guardar_credenciales(token, email, expires_in)
+    return data

ragfly_cli/config.py

@@ -0,0 +1,102 @@
+"""
+Configuración del cliente RAGfly.
+
+Lee de ~/.ragfly/config.env o variables de entorno.
+Patrón idéntico al backend (pydantic-settings + lru_cache).
+"""
+
+import os
+from pathlib import Path
+from functools import lru_cache
+from pydantic_settings import BaseSettings
+
+
+def _get_home() -> Path:
+    """Retorna el directorio home de RAGfly (evaluado en runtime)."""
+    return Path(os.environ.get("RAGFLY_HOME", Path.home() / ".ragfly"))
+
+
+# Directorio base de datos del cliente (evaluado al importar, útil como default)
+RAGFLY_HOME = _get_home()
+
+
+class ClienteConfig(BaseSettings):
+    """Configuración del cliente local."""
+
+    # --- Conexión al Cloud ---
+    cloud_url: str = ""
+    email: str = ""
+    password: str = ""  # TODO: encriptar con keyring en futuras versiones
+
+    # --- Tokens OAuth ---
+    # Si están presentes, `sync.py` los usa en vez de email/password para autenticar.
+    # NOTA: el flujo OAuth Authorization Code → localhost redirect que los poblaba
+    # vivía en `api_local.py` (servidor :27182), retirado 2026-06-19 (legado D.1).
+    # El SSO del Desktop GUI va por otro camino (auth_bridge → keyring del SO). El
+    # CLI puro autentica por email/password salvo que estos tokens se seteen aparte.
+    access_token: str = ""
+    refresh_token: str = ""
+
+    # --- Contexto multi-tenant ---
+    codigo_grupo: str = ""
+    codigo_entidad: str = ""
+
+    # --- Rutas locales ---
+    directorio_documentos: str = ""
+    db_path: str = str(RAGFLY_HOME / "data.db")
+
+    # NOTA: el cliente NO configura su modelo LLM ni de embeddings ni sus API
+    # keys. El modelo de cada paso lo gobierna la habilidad/transición
+    # sincronizada del cloud (registro_llm vía sync_catalogo) y las keys vienen
+    # de cat_llm_keys sincronizado. Cualquier "elección de modelo" debe vivir en
+    # el catálogo, nunca como literal en el cliente.
+
+    # --- Sync ---
+    sync_batch_size: int = 500
+    sync_max_reintentos: int = 5
+    sync_comprimir: bool = True
+
+    # --- Flags de pipeline ---
+    # Los flags `analizar_habilitado` / `chunkear_habilitado` fueron eliminados
+    # del cloud en mig 325 (limpieza de parámetros + parametrización por plan).
+    # El cliente asume True para todos los pasos; el control administrativo se
+    # hace en `rel_transiciones_estado.activo` del cloud.
+    # La vectorización ocurre SIEMPRE en el cloud con su modelo sincronizado
+    # (VECTORIZAR_CHUNKS → registro_llm); no hay embeddings local.
+
+    # --- General ---
+    debug: bool = False
+
+    model_config = {
+        "env_prefix": "RAGFLY_",
+        "extra": "ignore",
+    }
+
+    @classmethod
+    def settings_customise_sources(cls, settings_cls, **kwargs):
+        """Carga el env_file de forma dinámica (runtime) para que
+        RAGFLY_HOME sea respetado incluso si cambia después del import."""
+        from pydantic_settings import DotEnvSettingsSource
+        init_settings = kwargs.get("init_settings")
+        env_settings = kwargs.get("env_settings")
+        return (
+            init_settings,
+            env_settings,
+            DotEnvSettingsSource(settings_cls, env_file=str(_get_home() / "config.env")),
+        )
+
+
+@lru_cache
+def get_config() -> ClienteConfig:
+    """Retorna la configuración cacheada del cliente."""
+    return ClienteConfig()
+
+
+def config_existe() -> bool:
+    """Verifica si ya se ejecutó el setup (evaluado en runtime)."""
+    return (_get_home() / "config.env").exists()
+
+
+def crear_directorio_home():
+    """Crea ~/.ragfly/ si no existe (evaluado en runtime)."""
+    _get_home().mkdir(parents=True, exist_ok=True)

ragfly_cli/grupo_activo.py

@@ -0,0 +1,142 @@
+"""
+Gestión del grupo activo del RAGfly Cliente.
+
+El cliente sigue el mismo modelo que el dropdown del header web: el grupo
+activo es un override de sesión (no persiste en BD del cloud), pero sí se
+guarda localmente en `~/.ragfly/config.env` para que sobreviva entre
+ejecuciones del cliente.
+
+Funciones:
+    listar_grupos_disponibles(token) -> list[dict]
+    set_grupo_activo(codigo_grupo) -> None
+    clear_grupo_activo() -> None
+    get_grupo_activo_local() -> str | None
+    cambiar_grupo_remoto(codigo_grupo, token) -> dict   # valida con backend
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Optional
+
+import httpx
+
+from ._http import default_headers
+
+
+def _config_path() -> Path:
+    """Ruta al config.env (resuelta al llamar)."""
+    from .config import _get_home
+    return _get_home() / "config.env"
+
+
+# ── Persistencia local en ~/.ragfly/config.env ──────────────────────────────
+
+
+def get_grupo_activo_local() -> Optional[str]:
+    """Lee el grupo activo desde config (cargado por pydantic-settings)."""
+    from .config import get_config
+    return get_config().codigo_grupo or None
+
+
+def set_grupo_activo(codigo_grupo: str) -> None:
+    """Persiste `RAGFLY_CODIGO_GRUPO=codigo_grupo` en config.env.
+
+    Si la línea ya existe la reemplaza; si no, la agrega al final.
+    Invalida el cache de get_config() para que la próxima lectura sea fresca.
+    """
+    path = _config_path()
+    if not path.exists():
+        raise FileNotFoundError(
+            f"No existe {path}. Ejecuta `ragfly setup` primero."
+        )
+
+    content = path.read_text()
+    pattern = re.compile(r"^RAGFLY_CODIGO_GRUPO=.*$", re.MULTILINE)
+    new_line = f"RAGFLY_CODIGO_GRUPO={codigo_grupo}"
+
+    if pattern.search(content):
+        content = pattern.sub(new_line, content)
+    else:
+        if not content.endswith("\n"):
+            content += "\n"
+        content += new_line + "\n"
+
+    path.write_text(content)
+
+    from .config import get_config
+    get_config.cache_clear()
+
+
+def clear_grupo_activo() -> None:
+    """Quita RAGFLY_CODIGO_GRUPO del config.env (vuelve a grupo defecto del usuario)."""
+    set_grupo_activo("")
+
+
+def set_directorio_documentos(directorio: str) -> None:
+    """Persiste `RAGFLY_DIRECTORIO_DOCUMENTOS` en config.env (lo usa el pipeline
+    para resolver la ruta absoluta de cada archivo al extraer texto).
+
+    Crea el config.env si no existe (puede ocurrir antes del primer `setup`).
+    Invalida el cache de get_config() para que la próxima lectura sea fresca.
+    """
+    path = _config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    content = path.read_text() if path.exists() else ""
+
+    pattern = re.compile(r"^RAGFLY_DIRECTORIO_DOCUMENTOS=.*$", re.MULTILINE)
+    new_line = f"RAGFLY_DIRECTORIO_DOCUMENTOS={directorio}"
+    if pattern.search(content):
+        content = pattern.sub(new_line, content)
+    else:
+        if content and not content.endswith("\n"):
+            content += "\n"
+        content += new_line + "\n"
+    path.write_text(content)
+
+    from .config import get_config
+    get_config.cache_clear()
+
+
+# ── Operaciones contra el backend cloud ──────────────────────────────────────
+
+
+def listar_grupos_disponibles(token: str, cloud_url: str, *, timeout: int = 15) -> list[dict]:
+    """Retorna la lista de grupos a los que el usuario tiene acceso.
+
+    Cada item: `{codigo_grupo, nombre_grupo, alias_grupo}`.
+    """
+    r = httpx.get(
+        f"{cloud_url.rstrip('/')}/auth/me",
+        headers=default_headers(token=token),
+        timeout=timeout,
+    )
+    r.raise_for_status()
+    data = r.json()
+    return [
+        {
+            "codigo_grupo": g.get("codigo_grupo"),
+            "nombre_grupo": g.get("nombre_grupo"),
+            "alias_grupo": g.get("alias_grupo"),
+        }
+        for g in data.get("grupos", [])
+    ]
+
+
+def cambiar_grupo_remoto(
+    codigo_grupo: str, token: str, cloud_url: str, *, timeout: int = 15
+) -> dict:
+    """Llama POST /auth/cambiar-grupo para validar pertenencia y obtener contexto.
+
+    Retorna el `UsuarioContexto` actualizado del backend.
+    Lanza httpx.HTTPStatusError si el grupo no existe o el usuario no tiene acceso.
+    """
+    r = httpx.post(
+        f"{cloud_url.rstrip('/')}/auth/cambiar-grupo",
+        headers=default_headers(token=token, content_type=True),
+        json={"codigo_grupo": codigo_grupo},
+        timeout=timeout,
+    )
+    r.raise_for_status()
+    return r.json()

ragfly_cli/keyring_store.py

@@ -0,0 +1,70 @@
+"""
+Almacén persistente del JWT y email del usuario en el keyring del SO.
+
+- macOS: Keychain (Acceso a Llaveros)
+- Windows: Credential Manager
+- Linux: libsecret / Secret Service
+
+Doc 10 § 6 (SSO γ): el JWT se persiste fuera de SQLite y fuera del filesystem
+plano del usuario. Vive en el keyring del SO, accesible solo por la app y el
+usuario logueado en la sesión del SO.
+"""
+
+from __future__ import annotations
+
+import keyring
+from keyring.errors import KeyringError
+
+SERVICE = "ragfly-ragflydesktop"
+KEY_TOKEN = "jwt"
+KEY_EMAIL = "email"
+
+# Cache en RAM por sesión del proceso. Evita re-leer el Keychain en cada
+# llamada (cada lectura dispara un prompt del llavero cuando la app está
+# firmada ad-hoc, como en builds de desarrollo). Se lee una sola vez y se
+# refresca al guardar/borrar. Sentinela _NO_LEIDO distingue "no leído aún"
+# de "leído y vacío".
+_NO_LEIDO = object()
+_cache_token: object | str | None = _NO_LEIDO
+_cache_email: object | str | None = _NO_LEIDO
+
+
+def guardar(token: str, email: str) -> None:
+    global _cache_token, _cache_email
+    keyring.set_password(SERVICE, KEY_TOKEN, token)
+    keyring.set_password(SERVICE, KEY_EMAIL, email)
+    _cache_token = token
+    _cache_email = email
+
+
+def leer_token() -> str | None:
+    global _cache_token
+    if _cache_token is not _NO_LEIDO:
+        return _cache_token  # type: ignore[return-value]
+    try:
+        _cache_token = keyring.get_password(SERVICE, KEY_TOKEN)
+    except KeyringError:
+        _cache_token = None
+    return _cache_token  # type: ignore[return-value]
+
+
+def leer_email() -> str | None:
+    global _cache_email
+    if _cache_email is not _NO_LEIDO:
+        return _cache_email  # type: ignore[return-value]
+    try:
+        _cache_email = keyring.get_password(SERVICE, KEY_EMAIL)
+    except KeyringError:
+        _cache_email = None
+    return _cache_email  # type: ignore[return-value]
+
+
+def borrar() -> None:
+    global _cache_token, _cache_email
+    for k in (KEY_TOKEN, KEY_EMAIL):
+        try:
+            keyring.delete_password(SERVICE, k)
+        except KeyringError:
+            pass
+    _cache_token = None
+    _cache_email = None

ragfly_cli/oop/__init__.py

@@ -0,0 +1,12 @@
+"""
+Capa OOP del cliente — clases reutilizables para reducir duplicación.
+
+Componentes:
+  - CloudHttpClient — wrapper HTTP unificado contra la API cloud (GET/POST/PUT/DELETE)
+  - CliCommand — base class para comandos CLI con manejo uniforme de errores
+"""
+
+from ragfly_cli.oop.http_client import CloudHttpClient
+from ragfly_cli.oop.cli_command import CliCommand
+
+__all__ = ["CloudHttpClient", "CliCommand"]

ragfly_cli/oop/cli_command.py

@@ -0,0 +1,86 @@
+"""
+CliCommand — base class para comandos CLI con manejo uniforme de errores.
+
+Encapsula el patrón repetido en `cli.py`:
+    try:
+        data = operacion()
+    except CloudError as e:
+        err_console.print(f"[red]✗ {e}[/red]")
+        raise SystemExit(e.exit_code)
+
+Ejemplo:
+    from ragfly_cli.oop import CliCommand
+
+    class MiComando(CliCommand):
+        def ejecutar(self, x):
+            data = self.protegido(lambda: cloud_get(f"/algo/{x}"))
+            self.exito(f"Listo: {data}")
+
+    MiComando().ejecutar("foo")
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Any, Callable, NoReturn
+
+from rich.console import Console
+
+from ragfly_cli.cloud_commands import CloudError
+
+
+class CliCommand:
+    """Base class para comandos CLI con consoles + helpers de output."""
+
+    def __init__(self):
+        self.console = Console()
+        self.err_console = Console(stderr=True)
+
+    # ── Output helpers ────────────────────────────────────────────────────────
+
+    def exito(self, mensaje: str) -> None:
+        self.console.print(f"[green]✓ {mensaje}[/green]")
+
+    def error(self, mensaje: str) -> None:
+        self.err_console.print(f"[red]✗ {mensaje}[/red]")
+
+    def info(self, mensaje: str) -> None:
+        self.console.print(f"[dim]{mensaje}[/dim]")
+
+    def aviso(self, mensaje: str) -> None:
+        self.console.print(f"[yellow]⚠ {mensaje}[/yellow]")
+
+    def linea(self) -> None:
+        self.console.print()
+
+    # ── Ejecución protegida ───────────────────────────────────────────────────
+
+    def protegido(
+        self,
+        fn: Callable[..., Any],
+        *args,
+        on_unexpected_exit_code: int = 2,
+        **kwargs,
+    ) -> Any:
+        """
+        Ejecuta `fn(*args, **kwargs)` capturando CloudError y excepciones imprevistas;
+        imprime el error y termina con SystemExit usando el exit_code apropiado.
+        """
+        try:
+            return fn(*args, **kwargs)
+        except CloudError as e:
+            self.error(str(e))
+            raise SystemExit(e.exit_code)
+        except SystemExit:
+            raise
+        except KeyboardInterrupt:
+            self.aviso("Interrumpido.")
+            raise SystemExit(130)
+        except Exception as e:
+            self.error(f"Error inesperado: {e}")
+            raise SystemExit(on_unexpected_exit_code)
+
+    def salir(self, mensaje: str, exit_code: int = 1) -> NoReturn:
+        """Imprime el error y sale con el código dado."""
+        self.error(mensaje)
+        raise SystemExit(exit_code)