baucli 1.0.1__py3-none-any.whl

baucli/config.py

@@ -0,0 +1,244 @@
+"""BAUCLI — Configuration manager.
+
+Manages ~/.baucli/config.json with multi-database support.
+Passwords: keyring (macOS/Windows/Linux) → fallback to ~/.baucli/.credentials (mode 600).
+
+Env vars:
+    BAUCLI_HOME — override the config dir (default ~/.baucli). Lets one machine
+                  hold multiple isolated BAUCLI profiles (one per tenant), e.g.
+                  `BAUCLI_HOME=~/.baucli-beg baucli sync` and
+                  `BAUCLI_HOME=~/.baucli-ucbs baucli sync`.
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+
+# Per-profile root: env override → ~/.baucli fallback. Resolved once at import.
+BAUCLI_DIR = Path(os.environ["BAUCLI_HOME"]).expanduser() if os.environ.get("BAUCLI_HOME") \
+             else Path.home() / ".baucli"
+# Backwards-compat alias so any external code/tests referencing BAU_DIR still works.
+BAU_DIR = BAUCLI_DIR
+CONFIG_FILE = BAUCLI_DIR / "config.json"
+CREDS_FILE = BAUCLI_DIR / ".credentials"
+
+# Keyring service name is suffixed with the profile dir so credentials saved
+# under different BAUCLI_HOME values don't collide in a shared OS keychain.
+KEYRING_SERVICE = "baucli" if BAUCLI_DIR == Path.home() / ".baucli" \
+                  else f"baucli:{BAUCLI_DIR.name}"
+
+# Detect keyring availability at import time
+_keyring = None
+try:
+    import keyring as _keyring
+    # Test if backend is functional (headless Linux may have no backend)
+    _keyring.get_password(KEYRING_SERVICE, "__test__")
+except Exception:
+    _keyring = None
+
+DEFAULT_CONFIG = {
+    "license_key": None,
+    "api_url": "https://begbrokerdev.begcloud.com/ords/bauctx/api/v1",
+    "api_key": None,
+    "tenant_code": None,
+    "default_db": None,
+    "databases": {},
+    "sync_interval_min": 30,
+    "request_timeout": 30,
+    "context_output": "CLAUDE.md",
+    "session_token": None,
+    "session_expires_at": None,
+    "user_email": None,
+    "language": "en_US",
+}
+
+
+def ensure_dir():
+    """Create ~/.baucli/ if it doesn't exist."""
+    BAU_DIR.mkdir(parents=True, exist_ok=True)
+    # Restrict permissions on Unix
+    if sys.platform != "win32":
+        os.chmod(BAU_DIR, 0o700)
+
+
+def load_config() -> dict:
+    """Load config from ~/.baucli/config.json."""
+    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)
+    return merged
+
+
+def save_config(cfg: dict):
+    """Save config to ~/.baucli/config.json."""
+    ensure_dir()
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(cfg, f, indent=2, ensure_ascii=False)
+    if sys.platform != "win32":
+        os.chmod(CONFIG_FILE, 0o600)
+
+
+def load_credentials() -> dict:
+    """Load credentials from ~/.baucli/.credentials."""
+    if not CREDS_FILE.exists():
+        return {}
+    with open(CREDS_FILE) as f:
+        return json.load(f)
+
+
+def save_credentials(creds: dict):
+    """Save credentials to ~/.baucli/.credentials (restricted permissions)."""
+    ensure_dir()
+    with open(CREDS_FILE, "w") as f:
+        json.dump(creds, f, indent=2)
+    if sys.platform != "win32":
+        os.chmod(CREDS_FILE, 0o600)
+
+
+def get_db_password(db_name: str) -> Optional[str]:
+    """Get password for a database. Tries keyring first, then file."""
+    # Try keyring
+    if _keyring:
+        try:
+            pwd = _keyring.get_password(KEYRING_SERVICE, db_name)
+            if pwd:
+                return pwd
+        except Exception:
+            pass
+    # Fallback to file
+    creds = load_credentials()
+    return creds.get(db_name, {}).get("password")
+
+
+def set_db_password(db_name: str, password: str):
+    """Store password for a database. Uses keyring if available, else file."""
+    stored_in_keyring = False
+    if _keyring:
+        try:
+            _keyring.set_password(KEYRING_SERVICE, db_name, password)
+            stored_in_keyring = True
+        except Exception:
+            pass
+    if not stored_in_keyring:
+        # Fallback to file
+        creds = load_credentials()
+        if db_name not in creds:
+            creds[db_name] = {}
+        creds[db_name]["password"] = password
+        save_credentials(creds)
+    return stored_in_keyring
+
+
+def delete_db_password(db_name: str):
+    """Remove a database password from keyring + credentials file. Idempotent."""
+    if _keyring:
+        try:
+            _keyring.delete_password(KEYRING_SERVICE, db_name)
+        except Exception:
+            pass
+    creds = load_credentials()
+    if db_name in creds:
+        creds.pop(db_name, None)
+        save_credentials(creds)
+
+
+def get_database(cfg: dict, db_name: Optional[str] = None) -> tuple:
+    """Get database config by name or default.
+    
+    Returns (db_name, db_config) or (None, None) if not found.
+    """
+    dbs = cfg.get("databases", {})
+    if not dbs:
+        return None, None
+
+    name = db_name or cfg.get("default_db")
+    if name and name in dbs:
+        return name, dbs[name]
+
+    # If no default, return first
+    if not name and dbs:
+        first = next(iter(dbs))
+        return first, dbs[first]
+
+    return None, None
+
+
+def list_databases(cfg: dict) -> list:
+    """List all configured databases."""
+    result = []
+    default = cfg.get("default_db")
+    for name, db in cfg.get("databases", {}).items():
+        result.append({
+            "name": name,
+            "engine": db.get("engine", "?"),
+            "host": db.get("host", "?"),
+            "port": db.get("port", "?"),
+            "service": db.get("service"),
+            "wallet_path": db.get("wallet_path"),
+            "schemas": db.get("schemas", []),
+            "is_default": name == default,
+        })
+    return result
+
+
+def add_database(cfg: dict, name: str, engine: str, host: str, port: int,
+                 service: str = None, database: str = None,
+                 user: str = None, schemas: list = None,
+                 wallet_path: str = None) -> dict:
+    """Add a database to config.
+
+    wallet_path (Oracle only): directory of an unzipped Oracle Wallet used to
+    reach an Autonomous Database over mTLS TLS. When set, `service` is the TNS
+    alias from the wallet's tnsnames.ora (e.g. mydb_high) and host/port are
+    optional (the alias encodes the endpoint). Non-secret — the wallet password
+    (if any) lives in the keyring, never in config.json.
+    """
+    db = {
+        "engine": engine.lower(),
+        "host": host,
+        "port": port,
+        "user": user,
+        "schemas": schemas or [],
+    }
+    if engine.lower() == "oracle":
+        db["service"] = service or database
+        if wallet_path:
+            db["wallet_path"] = wallet_path
+    else:
+        db["database"] = database or service
+
+    if "databases" not in cfg:
+        cfg["databases"] = {}
+    cfg["databases"][name] = db
+
+    # Set as default if first database
+    if not cfg.get("default_db"):
+        cfg["default_db"] = name
+
+    return cfg
+
+
+def remove_database(cfg: dict, name: str) -> dict:
+    """Remove a database from config."""
+    cfg.get("databases", {}).pop(name, None)
+    # Remove credentials too
+    creds = load_credentials()
+    creds.pop(name, None)
+    save_credentials(creds)
+    # Reset default if needed
+    if cfg.get("default_db") == name:
+        dbs = cfg.get("databases", {})
+        cfg["default_db"] = next(iter(dbs)) if dbs else None
+    return cfg
+
+
+def is_configured() -> bool:
+    """Check if BAUCLI is minimally configured."""
+    cfg = load_config()
+    return bool(cfg.get("api_key") and cfg.get("license_key"))

baucli/db/__init__.py

@@ -0,0 +1,117 @@
+"""BAUCLI — Database extractors base class."""
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+
+class BauConnectionError(Exception):
+    """Raised when the BAUCLI cannot reach the source database.
+
+    Carries a short, actionable message (the friendly text shown to the user)
+    plus an optional raw cause for `--verbose` debugging. Callers should catch
+    this without printing a traceback — the user just needs to know whether
+    to fix the host, the credentials, or the database state.
+    """
+
+    def __init__(self, message: str, hint: str = None, cause: Exception = None):
+        super().__init__(message)
+        self.message = message
+        self.hint = hint
+        self.cause = cause
+
+
+class BaseExtractor(ABC):
+    """Abstract base for database extractors."""
+
+    engine: str = "UNKNOWN"
+
+    def __init__(self, host: str = None, port: int = None, user: str = None,
+                 password: str = None, service: str = None, database: str = None,
+                 wallet_path: str = None, wallet_password: str = None):
+        self.host = host
+        self.port = port
+        self.user = user
+        self.password = password
+        self.service = service
+        self.database = database
+        # Oracle Wallet (Autonomous DB over mTLS). wallet_path = unzipped wallet
+        # dir; wallet_password decrypts ewallet.pem in thin mode (may be None for
+        # auto-login SSO wallets used via thick mode).
+        self.wallet_path = wallet_path
+        self.wallet_password = wallet_password
+        self._conn = None
+
+    @abstractmethod
+    def connect(self):
+        """Establish database connection."""
+        pass
+
+    @abstractmethod
+    def disconnect(self):
+        """Close database connection."""
+        pass
+
+    @abstractmethod
+    def test_connection(self) -> dict:
+        """Test connection and return version info."""
+        pass
+
+    @abstractmethod
+    def get_native_identifier(self) -> Optional[str]:
+        """Get native database identifier (DBID, system_identifier, etc.)."""
+        pass
+
+    @abstractmethod
+    def extract_objects(self, schema: str, since_date: str = None, on_progress=None,
+                        name_filter: str = None) -> list:
+        """Extract PL/SQL objects (packages, functions, procedures, triggers).
+
+        Args:
+            schema: Schema/owner name
+            since_date: ISO date string — if set, only modified since this date
+            on_progress: callable(current, total, name) — called after each object
+            name_filter: case-insensitive exact OBJECT_NAME — when set, only that
+                         object is extracted (used by `baucli sync --object NAME`).
+
+        Returns list of dicts:
+        [{"name": "PKG_X", "type": "PACKAGE", "source": "CREATE...", "last_ddl": "2026-..."}]
+        """
+        pass
+
+    @abstractmethod
+    def extract_tables(self, schema: str, since_date: str = None, on_progress=None,
+                       name_filter: str = None) -> list:
+        """Extract table metadata (columns, types, constraints).
+
+        Args:
+            schema: Schema/owner name
+            since_date: ISO date string — if set, only modified since this date
+            on_progress: callable(current, total, name) — called after each table
+            name_filter: case-insensitive exact TABLE_NAME — when set, only that
+                         table is extracted (used by `baucli sync --table NAME`).
+
+        Returns list of dicts:
+        [{"name": "EMPLOYEES", "type": "TABLE", "columns": [...], "last_ddl": "2026-..."}]
+        """
+        pass
+
+    def count_objects(self, schema: str) -> int:
+        """Quick COUNT(*) of PL/SQL objects in schema. Override in subclass."""
+        return -1  # -1 = not supported
+
+    def count_tables(self, schema: str) -> int:
+        """Quick COUNT(*) of tables/views in schema. Override in subclass."""
+        return -1
+
+    def extract_all(self, schema: str, since_date: str = None) -> list:
+        """Extract both PL/SQL objects and tables."""
+        objects = self.extract_objects(schema, since_date=since_date)
+        tables = self.extract_tables(schema, since_date=since_date)
+        return objects + tables
+
+    def __enter__(self):
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.disconnect()