apowerb 0.1.2__py3-none-any.whl

apowerb/__init__.py

@@ -0,0 +1,18 @@
+"""
+Docstring for th2agent
+
+"""
+
+# Pydantic hack for Google ADK - must be applied before any google.adk imports
+try:
+    import mcp.client.session
+    from pydantic_core import core_schema
+
+    def __get_pydantic_core_schema__(cls, source_type, handler):
+        return core_schema.is_instance_schema(cls)
+
+    mcp.client.session.ClientSession.__get_pydantic_core_schema__ = classmethod(
+        __get_pydantic_core_schema__
+    )
+except ImportError:
+    pass

apowerb/agent_store/agent_manager.py

@@ -0,0 +1,159 @@
+from typing import Any
+from apowerb.configs.th2logger import setup_logging
+
+from pydantic import BaseModel
+from apowerb.helpers.database_connection import DBConfig
+
+from sqlalchemy import (
+    create_engine,
+    Table,
+    Column,
+    Integer,
+    String,
+    MetaData,
+    inspect,
+    UniqueConstraint,
+)
+from apowerb.configs.settings import get_settings
+
+logger = setup_logging(__name__)
+
+settings = get_settings()
+
+
+class AgentStoreConfig(DBConfig):
+    """Configuration for the agent store."""
+
+    table_name: str = settings.db_agent_store_table_name
+
+
+class AgentStore(BaseModel):
+    """Class to manage the agent store in a database.
+
+    Attributes:
+        db_host: str - The database host.
+        db_name: str - The database name.
+        db_url: str - The database URL.
+        table_name: str - The name of the agent table.
+        db_user: str - The database user.
+        db_password: str - The database password.
+        db_type: str - The type of the database.
+        db_schema: str - The database schema.
+        engine: Any - The SQLAlchemy engine instance.
+        metadata: Any - The SQLAlchemy metadata instance.
+        agent_table: Any - The SQLAlchemy table instance for agents.
+    """
+
+    agent_config: AgentStoreConfig = AgentStoreConfig()
+    db_host: str = agent_config.db_host
+    db_name: str = settings.db_name
+    db_url: str = f"{agent_config.db_host}:{agent_config.db_port}/{db_name}"
+    table_name: str = agent_config.table_name
+    db_user: str = agent_config.db_user
+    db_password: str = agent_config.db_password
+    db_type: str = agent_config.db_type
+    db_schema: str = agent_config.db_schema
+    engine: Any = None
+    metadata: Any = None
+    agent_table: Any = None
+
+    def __init__(self, **data: Any):
+        super().__init__(**data)
+        self.engine = create_engine(
+            f"{self.db_type}://{self.db_user}:{self.db_password}@{self.db_url}"
+        )
+        self.metadata = MetaData(schema=self.db_schema)
+        self.agent_table = Table(
+            self.table_name,
+            self.metadata,
+            Column("agent_id", Integer, primary_key=True, autoincrement=True),
+            Column("agent_name", String, nullable=False),
+            Column("agent_model", String, nullable=False),
+            Column("agent_model_params", String),
+            Column("agent_description", String),
+            Column("agent_instruction", String),
+            Column("agent_tools", String),
+            Column("agent_type", String),
+            Column("sub_agents", String),
+            Column("output_key", String),
+            Column("output_schema_name", String),
+            Column("skip_when_upstream", String),
+            Column("input_schema", String),
+            Column("output_schema", String),
+            Column("code_executor", String),
+            Column("created_at", String),
+            Column("updated_at", String),
+            Column("status", String),
+            Column("organization_id", String, nullable=False),
+            Column("project_id", String, nullable=False),
+            Column("owner_id", String),
+            Column("tags", String),
+            Column("guardrails_config", String),
+            Column("memory_enabled", String),
+            Column("artifacts_enabled", String),
+            Column("superagent_template_id", String),
+            Column("superagent_template_version_hash", String),
+            Column("loop_max_iterations", String),
+            Column("loop_exit_instruction", String),
+            Column("mcp_servers", String),
+            Column("agent_skills", String),
+            Column("hub_origin_id", String),
+            UniqueConstraint(
+                "agent_name",
+                "organization_id",
+                "project_id",
+                name="unique_agent_name_per_org_proj",
+            ),
+        )
+
+    def create_table(self):
+        """Create the agent metadata table in the database."""
+        if not inspect(self.engine).has_table(self.table_name):
+            self.metadata.create_all(self.engine)
+            logger.info(f"Agent store table '{self.table_name}' created successfully.")
+        else:
+            logger.info(f"Agent store table '{self.table_name}' already exists.")
+        self.ensure_columns()
+
+    def ensure_columns(self):
+        """Add new columns to existing tables if they don't exist."""
+        from sqlalchemy import text, inspect as sa_inspect
+
+        inspector = sa_inspect(self.engine)
+        existing = [
+            c["name"]
+            for c in inspector.get_columns(self.table_name, schema=self.db_schema)
+        ]
+        new_cols = {
+            "output_key": "VARCHAR",
+            "output_schema_name": "VARCHAR",
+            "skip_when_upstream": "VARCHAR",
+            "guardrails_config": "VARCHAR",
+            "memory_enabled": "VARCHAR",
+            "artifacts_enabled": "VARCHAR",
+            "superagent_template_id": "VARCHAR",
+            "loop_max_iterations": "VARCHAR",
+            "loop_exit_instruction": "VARCHAR",
+            "mcp_servers": "VARCHAR",
+            "agent_skills": "VARCHAR",
+            "hub_origin_id": "VARCHAR",
+            # Snapshot of the source template's hash-relevant fields at
+            # creation time. The UI compares it to the live template hash
+            # to surface "template updated, click to sync" banners.
+            "superagent_template_version_hash": "VARCHAR",
+        }
+        with self.engine.begin() as conn:
+            for col, typ in new_cols.items():
+                if col not in existing:
+                    schema_prefix = f'"{self.db_schema}".' if self.db_schema else ""
+                    conn.execute(
+                        text(
+                            f'ALTER TABLE {schema_prefix}"{self.table_name}" ADD COLUMN "{col}" {typ}'
+                        )
+                    )
+
+    def get_list_agents(self, agents_query: Any) -> Any:
+        """Get a list of all agents from the database."""
+        with self.engine.connect() as conn:
+            result = conn.execute(agents_query)
+            return result.fetchall()

apowerb/agent_store/api_key_store.py

@@ -0,0 +1,112 @@
+from typing import Any
+from apowerb.configs.th2logger import setup_logging
+from pydantic import BaseModel
+from apowerb.helpers.database_connection import DBConfig
+
+from sqlalchemy import (
+    create_engine,
+    Table,
+    Column,
+    Integer,
+    String,
+    MetaData,
+    inspect,
+)
+from apowerb.configs.settings import get_settings
+
+logger = setup_logging(__name__)
+
+settings = get_settings()
+
+
+class ApiKeyStoreConfig(DBConfig):
+    """Configuration for the API key store."""
+
+    table_name: str = "saved_api_keys"
+
+
+class ApiKeyStore(BaseModel):
+    """Class to manage saved API keys in a database."""
+
+    api_key_config: ApiKeyStoreConfig = ApiKeyStoreConfig()
+    db_host: str = api_key_config.db_host
+    db_name: str = settings.db_name
+    db_url: str = f"{api_key_config.db_host}:{api_key_config.db_port}/{db_name}"
+    table_name: str = api_key_config.table_name
+    db_user: str = api_key_config.db_user
+    db_password: str = api_key_config.db_password
+    db_type: str = api_key_config.db_type
+    db_schema: str = api_key_config.db_schema
+    engine: Any = None
+    metadata: Any = None
+    api_key_table: Any = None
+
+    def __init__(self, **data: Any):
+        super().__init__(**data)
+        self.engine = create_engine(
+            f"{self.db_type}://{self.db_user}:{self.db_password}@{self.db_url}"
+        )
+        self.metadata = MetaData(schema=self.db_schema)
+        self.api_key_table = Table(
+            self.table_name,
+            self.metadata,
+            Column("api_key_id", Integer, primary_key=True, autoincrement=True),
+            Column("key_name", String),
+            Column("provider", String),
+            Column("api_key_value", String),
+            Column("model", String, nullable=True),
+            Column("model_api_base", String, nullable=True),
+            Column("owner_id", String),
+            Column("organization_id", String),
+            Column("created_at", String),
+            Column("updated_at", String),
+            Column("status", String),
+        )
+
+    def create_table(self):
+        """Create the saved_api_keys table in the database."""
+        if not inspect(self.engine).has_table(self.table_name):
+            self.metadata.create_all(self.engine)
+            logger.info(
+                f"API key store table '{self.table_name}' created successfully."
+            )
+        else:
+            logger.info(f"API key store table '{self.table_name}' already exists.")
+        self.ensure_columns()
+
+    def ensure_columns(self):
+        """Add new columns to existing tables if they don't exist."""
+        from sqlalchemy import text, inspect as sa_inspect
+
+        inspector = sa_inspect(self.engine)
+        existing = [
+            c["name"]
+            for c in inspector.get_columns(self.table_name, schema=self.db_schema)
+        ]
+        new_cols: dict[str, str] = {
+            "model": "VARCHAR",
+            "model_api_base": "VARCHAR",
+        }
+        with self.engine.begin() as conn:
+            for col, typ in new_cols.items():
+                if col not in existing:
+                    schema_prefix = f'"{self.db_schema}".' if self.db_schema else ""
+                    conn.execute(
+                        text(
+                            f'ALTER TABLE {schema_prefix}"{self.table_name}" ADD COLUMN "{col}" {typ}'
+                        )
+                    )
+
+    def get_list(self, query: Any) -> Any:
+        """Execute a query and return all rows."""
+        with self.engine.connect() as conn:
+            result = conn.execute(query)
+            return result.fetchall()
+
+    def delete_api_key(self, api_key_id: int) -> None:
+        """Delete an API key by its numeric ID."""
+        delete_q = self.api_key_table.delete().where(
+            self.api_key_table.c.api_key_id == api_key_id
+        )
+        with self.engine.begin() as conn:
+            conn.execute(delete_q)

apowerb/agent_store/hub_manager.py

@@ -0,0 +1,121 @@
+from typing import Any
+from apowerb.configs.th2logger import setup_logging
+from pydantic import BaseModel
+from apowerb.helpers.database_connection import DBConfig
+
+from sqlalchemy import (
+    create_engine,
+    Table,
+    Column,
+    Integer,
+    String,
+    MetaData,
+    inspect,
+)
+from apowerb.configs.settings import get_settings
+
+logger = setup_logging(__name__)
+
+settings = get_settings()
+
+
+class HubStoreConfig(DBConfig):
+    """Configuration for the hub store."""
+
+    table_name: str = "hub_agents"
+
+
+class HubStore(BaseModel):
+    """Class to manage the hub agent store in a database."""
+
+    hub_config: HubStoreConfig = HubStoreConfig()
+    db_host: str = hub_config.db_host
+    db_name: str = settings.db_name
+    db_url: str = f"{hub_config.db_host}:{hub_config.db_port}/{db_name}"
+    table_name: str = hub_config.table_name
+    db_user: str = hub_config.db_user
+    db_password: str = hub_config.db_password
+    db_type: str = hub_config.db_type
+    db_schema: str = hub_config.db_schema
+    engine: Any = None
+    metadata: Any = None
+    hub_table: Any = None
+
+    def __init__(self, **data: Any):
+        super().__init__(**data)
+        self.engine = create_engine(
+            f"{self.db_type}://{self.db_user}:{self.db_password}@{self.db_url}"
+        )
+        self.metadata = MetaData(schema=self.db_schema)
+        self.hub_table = Table(
+            self.table_name,
+            self.metadata,
+            Column("hub_id", Integer, primary_key=True, autoincrement=True),
+            Column("hub_name", String, nullable=False),
+            Column("hub_description", String),
+            Column("hub_category", String),
+            Column("hub_tags", String),
+            # Snapshot of the original agent config (no API keys)
+            Column("agent_name", String),
+            Column("agent_model", String),
+            Column("agent_description", String),
+            Column("agent_instruction", String),
+            Column("agent_tools", String),
+            Column("agent_type", String),
+            Column("sub_agents", String),
+            Column("sub_agents_snapshot", String),
+            Column("loop_max_iterations", String),
+            Column("loop_exit_instruction", String),
+            Column("agent_skills", String),
+            Column("memory_enabled", String),
+            Column("artifacts_enabled", String),
+            Column("guardrails_config", String),
+            # Metadata
+            Column("publisher_id", String),
+            Column("publisher_org", String),
+            Column("source_agent_id", String),
+            Column("clone_count", Integer, default=0),
+            Column("published_at", String),
+            Column("updated_at", String),
+            Column("status", String),
+        )
+
+    def create_table(self):
+        """Create the hub_agents table in the database."""
+        if not inspect(self.engine).has_table(self.table_name):
+            self.metadata.create_all(self.engine)
+            logger.info(f"Hub store table '{self.table_name}' created successfully.")
+        else:
+            logger.info(f"Hub store table '{self.table_name}' already exists.")
+        self.ensure_columns()
+
+    def ensure_columns(self):
+        """Add new columns to existing tables if they don't exist."""
+        from sqlalchemy import text, inspect as sa_inspect
+
+        inspector = sa_inspect(self.engine)
+        existing = [
+            c["name"]
+            for c in inspector.get_columns(self.table_name, schema=self.db_schema)
+        ]
+        new_cols: dict[str, str] = {
+            "sub_agents_snapshot": "VARCHAR",
+            "loop_max_iterations": "VARCHAR",
+            "loop_exit_instruction": "VARCHAR",
+            "agent_skills": "VARCHAR",
+        }
+        with self.engine.begin() as conn:
+            for col, typ in new_cols.items():
+                if col not in existing:
+                    schema_prefix = f'"{self.db_schema}".' if self.db_schema else ""
+                    conn.execute(
+                        text(
+                            f'ALTER TABLE {schema_prefix}"{self.table_name}" ADD COLUMN "{col}" {typ}'
+                        )
+                    )
+
+    def get_list(self, query: Any) -> Any:
+        """Execute a query and return all rows."""
+        with self.engine.connect() as conn:
+            result = conn.execute(query)
+            return result.fetchall()

apowerb/auth/dependencies.py

@@ -0,0 +1,181 @@
+from apowerb.configs.th2logger import setup_logging
+import os
+from datetime import datetime
+from typing import Annotated
+
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+
+from jose import JWTError, jwt
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from apowerb.configs.settings import get_settings
+from apowerb.helpers.database import get_db
+from apowerb.helpers.security import get_algorithm, get_secret_key
+from apowerb.models import User as UserModel
+from apowerb.users import schemas as user_schemas
+
+logger = setup_logging(__name__)
+
+BYPASS_AUTH = os.environ.get("BYPASS_AUTH", "").lower() == "true"
+
+settings = get_settings()
+# Make authentication optional
+security = HTTPBearer(auto_error=False)
+DBSessionDep = Annotated[AsyncSession, Depends(get_db)]
+
+
+async def get_current_user(
+    credentials: HTTPAuthorizationCredentials | None = Depends(security),
+    db: AsyncSession = Depends(get_db),
+) -> user_schemas.User:
+    if BYPASS_AUTH:
+        logger.warning("AUTH BYPASS ACTIVE - Using fake user")
+
+        # Return fake user with ALL required fields
+        return user_schemas.User(
+            user_id=1,
+            email="test@example.com",
+            role="USER",
+            first_name="Test",
+            last_name="User",
+            onboarding_completed=True,
+            created_at=datetime.now(),
+            updated_at=datetime.now(),
+        )
+
+    if credentials is None:
+        logger.debug("No credentials provided for request")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Not authenticated",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    token = credentials.credentials
+    # La clé est résolue AVANT le try : une configuration manquante doit
+    # remonter telle quelle, pas se faire convertir en « identifiants
+    # invalides » par le except ci-dessous.
+    secret = get_secret_key()
+    try:
+        payload = jwt.decode(
+            token,
+            secret,
+            algorithms=[get_algorithm()],
+        )
+        # H1 — Reject any token that isn't explicitly an access token.
+        # Refresh tokens (30-day cookie) and long-lived agent_refresh tokens
+        # (90-day Mage schedule tokens) MUST NOT unlock user-scope endpoints.
+        token_type = payload.get("type")
+        if token_type != "access":
+            logger.warning(
+                "Rejected non-access token on protected endpoint (type=%s)",
+                token_type,
+            )
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid token type. Access token required.",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+        email: str = payload.get("sub")
+        if email is None:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Could not validate credentials",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+    except JWTError as e:
+        logger.warning("JWT decode failed: %s", type(e).__name__)
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Could not validate credentials",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    result = await db.execute(select(UserModel).where(UserModel.email == email))
+    user = result.scalar_one_or_none()
+
+    if user is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="User not found",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    return user_schemas.User(
+        user_id=user.user_id,
+        email=user.email,
+        role=user.role.value if hasattr(user.role, "value") else str(user.role),
+        first_name=user.first_name,
+        last_name=user.last_name,
+        username=user.username,
+        full_name=user.full_name,
+        avatar_url=user.avatar_url,
+        plan=user.plan,
+        stripe_customer_id=user.stripe_customer_id,
+        mfa_enabled=getattr(user, "mfa_enabled", False) or False,
+        onboarding_completed=getattr(user, "onboarding_completed", False) or False,
+        created_at=user.created_at,
+        updated_at=user.updated_at,
+    )
+
+
+async def get_optional_user(
+    credentials: HTTPAuthorizationCredentials | None = Depends(security),
+    db: AsyncSession = Depends(get_db),
+) -> user_schemas.User | None:
+    """Like get_current_user but returns None instead of 401 for unauthenticated requests."""
+    if credentials is None:
+        return None
+    token = credentials.credentials
+    secret = get_secret_key()
+    try:
+        payload = jwt.decode(
+            token,
+            secret,
+            algorithms=[get_algorithm()],
+        )
+        # H1 — Only accept explicit access tokens in optional-auth paths too.
+        if payload.get("type") != "access":
+            return None
+        email: str | None = payload.get("sub")
+        if email is None:
+            return None
+    except JWTError:
+        return None
+    result = await db.execute(select(UserModel).where(UserModel.email == email))
+    user = result.scalar_one_or_none()
+    if user is None:
+        return None
+    return user_schemas.User(
+        user_id=user.user_id,
+        email=user.email,
+        role=user.role.value if hasattr(user.role, "value") else str(user.role),
+        first_name=user.first_name,
+        last_name=user.last_name,
+        username=user.username,
+        full_name=user.full_name,
+        avatar_url=user.avatar_url,
+        plan=user.plan,
+        stripe_customer_id=user.stripe_customer_id,
+        mfa_enabled=getattr(user, "mfa_enabled", False) or False,
+        onboarding_completed=getattr(user, "onboarding_completed", False) or False,
+        created_at=user.created_at,
+        updated_at=user.updated_at,
+    )
+
+
+async def get_admin_user(
+    current_user: user_schemas.User = Depends(get_current_user),
+) -> user_schemas.User:
+    if BYPASS_AUTH:
+        logger.warning("ADMIN BYPASS ACTIVE")
+        current_user.role = "ADMIN"
+        return current_user
+
+    if getattr(current_user, "role", None) != "ADMIN":
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN, detail="Not enough permissions"
+        )
+    return current_user

apowerb/auth/exceptions.py

@@ -0,0 +1,7 @@
+class InvalidCredentials(Exception):
+    pass
+
+
+class EmailNotVerified(Exception):
+    """Raised at login when the account email is not verified yet."""
+    pass