baucli 1.0.1__tar.gz → 1.0.3__tar.gz

{baucli-1.0.1 → baucli-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: baucli
-Version: 1.0.1
+Version: 1.0.3
 Summary: BAUCLI — AI-powered database documentation CLI for BAU
 Home-page: https://www.begcloud.com
 Author: BEG Support

{baucli-1.0.1 → baucli-1.0.3}/baucli/__init__.py

@@ -3,6 +3,6 @@
 import warnings
 warnings.filterwarnings("ignore", message="urllib3 v2 only supports OpenSSL")
 
-__version__ = "1.0.1"
+__version__ = "1.0.3"
 __product__ = "BAUCLI"
 __author__ = "BEG Support"

{baucli-1.0.1 → baucli-1.0.3}/baucli/api.py

@@ -822,6 +822,11 @@ class BauApi:
         """GET /quota — Full quota status."""
         return self._request("GET", "quota")
 
+    def whoami(self) -> dict:
+        """GET /whoami — dono (BAU_USERS) da API key atual: user_email/name/role,
+        tenant_code, key_prefix. Usado por `status` e pelo cabeçalho."""
+        return self._request("GET", "whoami")
+
     # ── DOCAPEX endpoints ──
 
     def apex_sync(self, payload: dict) -> dict:

{baucli-1.0.1 → baucli-1.0.3}/baucli/cli.py

@@ -36,6 +36,7 @@ from baucli.config import (
     load_config, save_config, is_configured, get_database,
     add_database, remove_database, list_databases, set_db_password,
     get_db_password, delete_db_password, DEFAULT_CONFIG,
+    BauConfigError,
 )
 from baucli.api import BauApi, BauApiError, BauSessionError
 from baucli.sync import sync_database, sync_all, get_extractor, get_sync_recommendation, PARALLEL_THRESHOLD
@@ -54,6 +55,13 @@ def show_db_panel(title: str, db_name: str = None, db_config: dict = None,
     lines = [f"[bold red]{__product__} v{__version__}[/bold red] — {title}"]
     lines.append("")
 
+    # Dono da API key (cacheado por `status`/`init` via GET /whoami).
+    if cfg.get("key_user_email"):
+        _who = cfg["key_user_email"]
+        if cfg.get("key_user_name"):
+            _who += f" ({cfg['key_user_name']})"
+        lines.append(f"  Usuário:    [cyan]{_who}[/cyan]")
+
     if db_name and db_config:
         engine = db_config.get("engine", "?").upper()
         host = db_config.get("host", "?")
@@ -79,7 +87,8 @@ def show_db_panel(title: str, db_name: str = None, db_config: dict = None,
         if uuid != "—":
             lines.append(f"  BAU UUID:   {uuid}")
     else:
-        lines.append(f"  License:    [cyan]{cfg.get('license_key', '—')}[/cyan]")
+        if cfg.get("license_key"):
+            lines.append(f"  License:    [cyan]{cfg['license_key']}[/cyan]")
         lines.append(f"  Server:     {cfg.get('api_url', '—')}")
         lines.append(f"  Tenant:     {cfg.get('tenant_code', '—')}")
         lines.append(f"  Language:   [cyan]{cfg.get('language') or 'en_US (default)'}[/cyan]")
@@ -134,7 +143,9 @@ def _do_login(cfg: dict, email: str, password: str) -> bool:
 # ═══════════════════════════════════════════════════════════
 @click.group()
 @click.version_option(__version__, prog_name=__product__)
-def main():
+@click.option("--profile", "profile", default=None,
+              help="Perfil de credencial a usar nesta invocação (sobrepõe bau.toml/default).")
+def main(profile):
     """BAUCLI — AI-powered database documentation.
 
     \b
@@ -144,7 +155,8 @@ def main():
       baucli sync
       baucli context
     """
-    pass
+    if profile:
+        os.environ["BAUCLI_PROFILE"] = profile
 
 
 # ── Aviso global: "golden desatualizado" ────────────────────────────
@@ -390,6 +402,18 @@ def _run_init(license_key: str, api_key_manual: str, api_url: str,
         except BauApiError:
             pass
 
+        # Dono da API key (cacheia p/ o cabeçalho + confirma no init)
+        try:
+            me = api.whoami()
+            if isinstance(me, dict) and me.get("status") == "ok":
+                cfg["key_user_email"] = me.get("user_email")
+                cfg["key_user_name"] = me.get("user_name")
+                save_config(cfg)
+                _uname = f" ({me.get('user_name')})" if me.get("user_name") else ""
+                console.print(f"  Usuário:    [green]{me.get('user_email')}[/green]{_uname}")
+        except BauApiError:
+            pass
+
         from .config import CONFIG_FILE
         console.print()
         console.print(f"[green]Config saved to {CONFIG_FILE}[/green]")
@@ -1846,6 +1870,113 @@ def _write_root_pointer_md(current_schema: str, primary_locale: str,
     pointer.write_text(new_content, encoding="utf-8")
 
 
+# ═══════════════════════════════════════════════════════════
+# baucli profile  (Fase 1 — perfis de credencial por tenant)
+# ═══════════════════════════════════════════════════════════
+@main.group()
+def profiles():
+    """Perfis de credencial (1 BAUCLI_HOME, N tenants).
+
+    \b
+      profiles add NOME --tenant T --api-key K [--base-url U] [--db DB] [--default]
+      profiles ls
+      profiles use NOME
+      profiles rm NOME
+    O bau.toml do projeto escolhe o perfil por [bau].profile (sem segredo no repo).
+    """
+    pass
+
+
+@profiles.command("add")
+@click.argument("name")
+@click.option("--tenant", "tenant_code", default=None, help="Código do tenant (ex.: GRUPO_DASS).")
+@click.option("--api-key", "api_key", required=True, help="API key do dev nesse tenant (bau_...).")
+@click.option("--base-url", "base_url", default=None, help="URL da API (default: a do config).")
+@click.option("--db", "default_db", default=None, help="Alias de database default do perfil.")
+@click.option("--default", "make_default", is_flag=True, help="Torna este o perfil default do BAUCLI_HOME.")
+def profile_add(name, tenant_code, api_key, base_url, default_db, make_default):
+    """Cria/atualiza um perfil e grava sua api_key no keyring."""
+    from .config import load_config as _lc, save_config, set_profile_api_key
+    cfg = _lc(apply_profile=False)
+    profiles = cfg.setdefault("profiles", {})
+    entry = profiles.get(name, {})
+    if tenant_code:
+        entry["tenant_code"] = tenant_code
+    if base_url:
+        entry["base_url"] = base_url
+    if default_db:
+        entry["default_db"] = default_db
+    profiles[name] = entry
+    if make_default or not cfg.get("default_profile"):
+        cfg["default_profile"] = name
+    save_config(cfg)
+    in_kr = set_profile_api_key(name, api_key)
+    tail = " (default do BAUCLI_HOME)" if cfg.get("default_profile") == name else ""
+    console.print(f"[green]Perfil '{name}' salvo{tail}[/green] — chave no "
+                  f"{'keyring' if in_kr else '.credentials'}.")
+
+
+@profiles.command("ls")
+def profile_ls():
+    """Lista os perfis do BAUCLI_HOME e qual está ativo."""
+    from .config import load_config as _lc, resolve_profile_name, get_profile_api_key
+    cfg = _lc(apply_profile=False)
+    profiles = cfg.get("profiles", {})
+    if not profiles:
+        console.print("  [yellow]Nenhum perfil.[/yellow] Crie: "
+                      "[cyan]baucli profile add NOME --tenant T --api-key K[/cyan]")
+        return
+    try:
+        active = resolve_profile_name(cfg)
+    except Exception:
+        active = None
+    default = cfg.get("default_profile")
+    table = RichTable(title=f"Perfis ({len(profiles)})", border_style="dim")
+    table.add_column("Nome", style="cyan")
+    table.add_column("Tenant")
+    table.add_column("DB default")
+    table.add_column("Chave")
+    table.add_column("Default", style="yellow")
+    table.add_column("Ativo", style="green")
+    for n, p in profiles.items():
+        table.add_row(n, p.get("tenant_code", "—"), p.get("default_db", "—"),
+                      "sim" if get_profile_api_key(n) else "—",
+                      "★" if n == default else "", "●" if n == active else "")
+    console.print(table)
+    console.print("  [dim]Ativo = env BAUCLI_PROFILE > bau.toml [bau].profile > default.[/dim]")
+
+
+@profiles.command("use")
+@click.argument("name")
+def profile_use(name):
+    """Define o perfil default do BAUCLI_HOME."""
+    from .config import load_config as _lc, save_config
+    cfg = _lc(apply_profile=False)
+    if name not in cfg.get("profiles", {}):
+        console.print(f"[red]Perfil '{name}' não existe.[/red] Veja: baucli profile ls")
+        raise SystemExit(1)
+    cfg["default_profile"] = name
+    save_config(cfg)
+    console.print(f"[green]Perfil default = '{name}'.[/green]")
+
+
+@profiles.command("rm")
+@click.argument("name")
+def profile_rm(name):
+    """Remove um perfil e sua api_key."""
+    from .config import load_config as _lc, save_config, delete_profile_api_key
+    cfg = _lc(apply_profile=False)
+    if name not in cfg.get("profiles", {}):
+        console.print(f"[yellow]Perfil '{name}' já não existe.[/yellow]")
+        return
+    cfg["profiles"].pop(name, None)
+    if cfg.get("default_profile") == name:
+        cfg["default_profile"] = next(iter(cfg["profiles"]), None)
+    save_config(cfg)
+    delete_profile_api_key(name)
+    console.print(f"[green]Perfil '{name}' removido.[/green]")
+
+
 # ═══════════════════════════════════════════════════════════
 # baucli status
 # ═══════════════════════════════════════════════════════════
@@ -1854,6 +1985,21 @@ def status():
     """Show agent config, quota, and pending deploys."""
     cfg = load_config()
 
+    if cfg.get("_active_profile"):
+        console.print(f"[dim]Perfil ativo:[/dim] [cyan]{cfg['_active_profile']}[/cyan] "
+                      f"· tenant {cfg.get('tenant_code') or '—'}")
+
+    # Resolve o dono da API key (ao vivo) e cacheia p/ o cabeçalho.
+    if cfg.get("api_key"):
+        try:
+            me = get_api(cfg).whoami()
+            if isinstance(me, dict) and me.get("status") == "ok":
+                cfg["key_user_email"] = me.get("user_email")
+                cfg["key_user_name"] = me.get("user_name")
+                save_config(cfg)
+        except Exception:
+            pass
+
     show_db_panel("Status")
 
     # Databases table
@@ -7750,5 +7896,58 @@ def rag_search_cmd(pergunta, schema, top):
                       f"[bold]{it['key']}[/bold]: {it['text'][:140]}")
 
 
+def _report_crash(exc: Exception):
+    """Salva o traceback completo num log local e mostra mensagem de Suporte."""
+    import traceback
+    import time
+    from baucli.config import BAUCLI_DIR
+    log_path = None
+    try:
+        BAUCLI_DIR.mkdir(parents=True, exist_ok=True)
+        log_path = BAUCLI_DIR / "last_error.log"
+        with open(log_path, "w", encoding="utf-8") as f:
+            f.write(f"{__product__} v{__version__}\n")
+            f.write(f"cmd:  {' '.join(sys.argv)}\n")
+            f.write(f"time: {time.strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+            f.write("".join(traceback.format_exception(type(exc), exc, exc.__traceback__)))
+    except Exception:
+        log_path = None
+    console.print()
+    console.print("[red]Ops — o BAUCLI encontrou um erro inesperado e não conseguiu concluir a operação.[/red]")
+    console.print(f"  [dim]{type(exc).__name__}: {exc}[/dim]")
+    console.print("  Contate o [bold]Suporte BEG[/bold]: [cyan]www.begcloud.com[/cyan]")
+    if log_path:
+        console.print(f"  Anexe este arquivo ao chamado: [cyan]{log_path}[/cyan]")
+    console.print("  [dim]Detalhe técnico (devs): rode de novo com BAUCLI_DEBUG=1[/dim]")
+
+
+def cli():
+    """Entry point do console com captura GLOBAL de erros (UX amigável).
+
+    - Erros de configuração (JSON inválido) → mensagem clara e auto-corrigível.
+    - Ctrl-C → 'Cancelado.'.
+    - Qualquer erro não tratado → mensagem de Suporte + traceback salvo em
+      BAUCLI_HOME/last_error.log. BAUCLI_DEBUG=1 mostra o traceback cru.
+    Erros de uso do Click (opção inválida etc.) seguem o comportamento padrão.
+    """
+    try:
+        main(standalone_mode=True)
+    except SystemExit:
+        raise
+    except KeyboardInterrupt:
+        console.print("\n[dim]Cancelado.[/dim]")
+        sys.exit(130)
+    except BauConfigError as e:
+        console.print(f"[red]Configuração inválida.[/red]\n{e}")
+        sys.exit(1)
+    except click.ClickException:
+        raise
+    except Exception as e:  # noqa: BLE001 — captura geral proposital
+        if os.environ.get("BAUCLI_DEBUG"):
+            raise
+        _report_crash(e)
+        sys.exit(1)
+
+
 if __name__ == "__main__":
-    main()
+    cli()

{baucli-1.0.1 → baucli-1.0.3}/baucli/config.py

@@ -38,6 +38,12 @@ try:
 except Exception:
     _keyring = None
 
+class BauConfigError(Exception):
+    """Problema no arquivo de configuração que o próprio usuário pode corrigir
+    (ex.: JSON malformado). Tratado pela CLI com mensagem clara — sem traceback,
+    sem 'contate o Suporte' (é auto-corrigível)."""
+
+
 DEFAULT_CONFIG = {
     "license_key": None,
     "api_url": "https://begbrokerdev.begcloud.com/ords/bauctx/api/v1",
@@ -52,6 +58,8 @@ DEFAULT_CONFIG = {
     "session_expires_at": None,
     "user_email": None,
     "language": "en_US",
+    "profiles": {},
+    "default_profile": None,
 }
 
 
@@ -63,23 +71,73 @@ def ensure_dir():
         os.chmod(BAU_DIR, 0o700)
 
 
-def load_config() -> dict:
-    """Load config from ~/.baucli/config.json."""
+_in_profile_apply = False
+
+
+def load_config(apply_profile: bool = True) -> dict:
+    """Load config from ~/.baucli/config.json.
+
+    When profiles are defined AND ``apply_profile`` is True, overlays the active
+    profile's credential (api_url / tenant_code / default_db / api_key) onto the
+    flat config so every consumer (CLI + MCP) transparently uses the right
+    (tenant, key). Precedence of the active profile: env BAUCLI_PROFILE >
+    bau.toml [bau].profile > config.json default_profile. No profiles / no match
+    → identical to the legacy flat behavior. Pass ``apply_profile=False`` to get
+    the raw config (used by the profile-management commands themselves).
+    """
     if not CONFIG_FILE.exists():
-        return DEFAULT_CONFIG.copy()
-    with open(CONFIG_FILE) as f:
-        cfg = json.load(f)
-    # Merge with defaults for missing keys
-    merged = DEFAULT_CONFIG.copy()
-    merged.update(cfg)
+        merged = DEFAULT_CONFIG.copy()
+    else:
+        try:
+            with open(CONFIG_FILE) as f:
+                cfg = json.load(f)
+        except json.JSONDecodeError as e:
+            raise BauConfigError(
+                f"O arquivo de configuração está com JSON inválido:\n"
+                f"  {CONFIG_FILE}\n"
+                f"  → linha {e.lineno}, coluna {e.colno} ({e.msg}).\n"
+                f"Dica: todo valor de texto precisa de aspas (ex.: "
+                f"\"tenant_code\": \"GRUPO_DASS\"); só null/true/false/números ficam sem.\n"
+                f"Valide com: python3 -m json.tool {CONFIG_FILE}"
+            ) from e
+        # Merge with defaults for missing keys
+        merged = DEFAULT_CONFIG.copy()
+        merged.update(cfg)
+
+    global _in_profile_apply
+    if apply_profile and merged.get("profiles") and not _in_profile_apply:
+        try:
+            _in_profile_apply = True
+            name = resolve_profile_name(merged)
+            if name:
+                _apply_profile(merged, name)
+        except Exception:
+            pass
+        finally:
+            _in_profile_apply = False
     return merged
 
 
 def save_config(cfg: dict):
-    """Save config to ~/.baucli/config.json."""
+    """Save config to ~/.baucli/config.json.
+
+    Never persists a profile overlay into the flat config: strips the transient
+    `_active_profile`/`_pre_profile` markers and, for each key the active profile
+    overlaid, writes the PRE-profile (raw) value back — unless the caller changed
+    it on purpose (then the caller's value wins). Keeps profile secrets out of
+    config.json and prevents a load→mutate→save from leaking one tenant's key.
+    """
     ensure_dir()
+    to_write = dict(cfg)
+    pre = to_write.pop("_pre_profile", None)
+    to_write.pop("_active_profile", None)
+    if pre:
+        for k, ov in pre.items():
+            raw, overlaid = ov[0], ov[1]
+            if to_write.get(k) == overlaid:   # caller didn't change it → restore raw
+                to_write[k] = raw
     with open(CONFIG_FILE, "w") as f:
-        json.dump(cfg, f, indent=2, ensure_ascii=False)
+        json.dump(to_write, f, indent=2, ensure_ascii=False)
     if sys.platform != "win32":
         os.chmod(CONFIG_FILE, 0o600)
 
@@ -148,6 +206,98 @@ def delete_db_password(db_name: str):
         save_credentials(creds)
 
 
+# ── Profiles (Fase 1: 1 BAUCLI_HOME, N perfis por tenant) ──────────────────
+# Um "profile" é uma credencial NOMEADA: {tenant_code, base_url, default_db} no
+# config.json + a api_key no keyring (namespaced). O bau.toml do projeto escolhe
+# o perfil por nome lógico ([bau].profile) — sem segredo no repo. Precedência do
+# perfil ativo: env BAUCLI_PROFILE > [bau].profile > config.json default_profile.
+
+def _profile_keyring_user(name: str) -> str:
+    return f"__profile__:{name}"
+
+
+def get_profile_api_key(name: str) -> Optional[str]:
+    """API key do perfil: keyring primeiro, senão o arquivo .credentials."""
+    if _keyring:
+        try:
+            k = _keyring.get_password(KEYRING_SERVICE, _profile_keyring_user(name))
+            if k:
+                return k
+        except Exception:
+            pass
+    return load_credentials().get(_profile_keyring_user(name), {}).get("api_key")
+
+
+def set_profile_api_key(name: str, api_key: str) -> bool:
+    """Grava a api_key do perfil (keyring se houver, senão .credentials)."""
+    if _keyring:
+        try:
+            _keyring.set_password(KEYRING_SERVICE, _profile_keyring_user(name), api_key)
+            return True
+        except Exception:
+            pass
+    creds = load_credentials()
+    creds.setdefault(_profile_keyring_user(name), {})["api_key"] = api_key
+    save_credentials(creds)
+    return False
+
+
+def delete_profile_api_key(name: str):
+    """Remove a api_key do perfil (keyring + .credentials). Idempotente."""
+    if _keyring:
+        try:
+            _keyring.delete_password(KEYRING_SERVICE, _profile_keyring_user(name))
+        except Exception:
+            pass
+    creds = load_credentials()
+    if _profile_keyring_user(name) in creds:
+        creds.pop(_profile_keyring_user(name), None)
+        save_credentials(creds)
+
+
+def _project_profile() -> Optional[str]:
+    """[bau].profile do bau.toml mais próximo (walk-up). None em qualquer falha."""
+    try:
+        from .project import find_project
+        proj = find_project()
+        return proj.profile if proj else None
+    except Exception:
+        return None
+
+
+def resolve_profile_name(cfg: dict) -> Optional[str]:
+    """Nome do perfil ativo: env BAUCLI_PROFILE > [bau].profile > default_profile."""
+    return (os.environ.get("BAUCLI_PROFILE")
+            or _project_profile()
+            or cfg.get("default_profile"))
+
+
+def _apply_profile(cfg: dict, name: str) -> dict:
+    """Overlay dos campos do perfil sobre o cfg flat (in-place).
+
+    Registra em `_pre_profile` {campo: [raw, overlaid]} para o save_config poder
+    reverter (nunca persistir a chave do perfil nos campos flat)."""
+    prof = (cfg.get("profiles") or {}).get(name)
+    if not prof:
+        return cfg
+    pre = {}
+
+    def _ov(key, val):
+        if val is None:
+            return
+        pre[key] = [cfg.get(key), val]
+        cfg[key] = val
+
+    _ov("api_url", prof.get("base_url"))
+    _ov("tenant_code", prof.get("tenant_code"))
+    _ov("default_db", prof.get("default_db"))
+    _ov("api_key", get_profile_api_key(name))
+    cfg["_active_profile"] = name
+    if pre:
+        cfg["_pre_profile"] = pre
+    return cfg
+
+
 def get_database(cfg: dict, db_name: Optional[str] = None) -> tuple:
     """Get database config by name or default.
     

{baucli-1.0.1 → baucli-1.0.3}/baucli/project.py

@@ -88,6 +88,14 @@ class Project:
         v = self._get("project", "scope")
         return v.upper() if v else None
 
+    # -- [bau] -------------------------------------------------------------
+    @property
+    def profile(self) -> str | None:
+        """[bau].profile — nome lógico do perfil de credencial (BAUCLI_HOME).
+        Seleciona qual (tenant, chave) o baucli/MCP usam neste projeto, sem
+        segredo no repo. Precedência: env BAUCLI_PROFILE > este > default_profile."""
+        return self._get("bau", "profile")
+
     # -- [connection] ------------------------------------------------------
     @property
     def connection_name(self) -> str | None:

{baucli-1.0.1 → baucli-1.0.3}/baucli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: baucli
-Version: 1.0.1
+Version: 1.0.3
 Summary: BAUCLI — AI-powered database documentation CLI for BAU
 Home-page: https://www.begcloud.com
 Author: BEG Support

baucli-1.0.3/baucli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+baucli = baucli.cli:cli

{baucli-1.0.1 → baucli-1.0.3}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="baucli",
-    version="1.0.1",
+    version="1.0.3",
     description="BAUCLI — AI-powered database documentation CLI for BAU",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",
@@ -28,7 +28,7 @@ setup(
     },
     entry_points={
         "console_scripts": [
-            "baucli=baucli.cli:main",
+            "baucli=baucli.cli:cli",
         ],
     },
     classifiers=[

baucli-1.0.1/baucli.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-baucli = baucli.cli:main