appmanager-server 0.2.0__py3-none-any.whl

appmanager/config.py

@@ -0,0 +1,58 @@
+import os
+from datetime import timedelta
+
+from dotenv import load_dotenv
+
+# Automatically load .env if present in current working directory or base directory
+load_dotenv()
+
+DEFAULT_BASE_DIR = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
+BASE_DIR = os.getenv("APPMANAGER_BASE_DIR", DEFAULT_BASE_DIR)
+
+
+class Config:
+    BASE_DIR = BASE_DIR
+    TEMPLATES_AUTO_RELOAD = os.getenv("TEMPLATES_AUTO_RELOAD", "true").lower() in (
+        "true",
+        "1",
+        "yes",
+    )
+    SECRET_KEY = os.getenv(
+        "SECRET_KEY", "appmanager-super-secret-key-change-in-production-min-32-chars"
+    )
+    JWT_SECRET = os.getenv("JWT_SECRET", "jwt-secret-key-change-in-production-min-32-chars")
+    JWT_ACCESS_TOKEN_EXPIRES = timedelta(days=int(os.getenv("JWT_ACCESS_TOKEN_EXPIRES_DAYS", 7)))
+    MAGIC_LINK_EXPIRES_MINUTES = int(os.getenv("MAGIC_LINK_EXPIRES_MINUTES", 15))
+
+    SQLALCHEMY_DATABASE_URI = os.getenv(
+        "DATABASE_URL", f"sqlite:///{os.path.join(BASE_DIR, 'instance', 'appmanager.db')}"
+    )
+    SQLALCHEMY_TRACK_MODIFICATIONS = False
+
+    # Storage paths for sub-apps
+    INSTALLED_APPS_DIR = os.getenv("INSTALLED_APPS_DIR", os.path.join(BASE_DIR, "installed_apps"))
+    TEMP_UPLOAD_DIR = os.getenv("TEMP_UPLOAD_DIR", os.path.join(BASE_DIR, "instance", "uploads"))
+
+    # OAuth Settings
+    GOOGLE_CLIENT_ID = os.getenv("GOOGLE_CLIENT_ID", "")
+    GOOGLE_CLIENT_SECRET = os.getenv("GOOGLE_CLIENT_SECRET", "")
+    GOOGLE_DISCOVERY_URL = os.getenv(
+        "GOOGLE_DISCOVERY_URL", "https://accounts.google.com/.well-known/openid-configuration"
+    )
+
+    # SMTP Settings (Optional, logs to console if empty)
+    SMTP_SERVER = os.getenv("SMTP_SERVER", "")
+    SMTP_PORT = int(os.getenv("SMTP_PORT", 587))
+    SMTP_USER = os.getenv("SMTP_USER", "")
+    SMTP_PASSWORD = os.getenv("SMTP_PASSWORD", "")
+    MAIL_DEFAULT_SENDER = os.getenv("MAIL_DEFAULT_SENDER", "noreply@appmanager.local")
+    APP_BASE_URL = os.getenv("APP_BASE_URL", "http://localhost:5000")
+
+    # Security settings
+    SESSION_COOKIE_HTTPONLY = True
+    SESSION_COOKIE_SAMESITE = os.getenv("SESSION_COOKIE_SAMESITE", "Lax")
+    SESSION_COOKIE_SECURE = os.getenv("SESSION_COOKIE_SECURE", "false").lower() in (
+        "true",
+        "1",
+        "yes",
+    )

appmanager/database.py

@@ -0,0 +1,120 @@
+from flask_sqlalchemy import SQLAlchemy
+
+db = SQLAlchemy()
+
+
+def init_db(app):
+    db.init_app(app)
+    with app.app_context():
+        db.create_all()
+        # Auto-migrate missing columns for SQLite
+        try:
+            from sqlalchemy import inspect, text
+
+            engine = db.engine
+            inspector = inspect(engine)
+            tables = inspector.get_table_names()
+            with engine.connect() as conn:
+                if "installed_apps" in tables:
+                    columns = [c["name"] for c in inspector.get_columns("installed_apps")]
+                    if "requires_auth" not in columns:
+                        conn.execute(
+                            text(
+                                "ALTER TABLE installed_apps ADD COLUMN requires_auth BOOLEAN DEFAULT 1 NOT NULL"
+                            )
+                        )
+                        conn.commit()
+                    if "is_default" not in columns:
+                        conn.execute(
+                            text(
+                                "ALTER TABLE installed_apps ADD COLUMN is_default BOOLEAN DEFAULT 0 NOT NULL"
+                            )
+                        )
+                        conn.commit()
+                    if "app_type" not in columns:
+                        conn.execute(
+                            text(
+                                "ALTER TABLE installed_apps ADD COLUMN app_type VARCHAR(50) DEFAULT 'standalone' NOT NULL"
+                            )
+                        )
+                        conn.commit()
+                    if "target_app" not in columns:
+                        conn.execute(
+                            text("ALTER TABLE installed_apps ADD COLUMN target_app VARCHAR(100)")
+                        )
+                        conn.commit()
+                    if "has_web_ui" not in columns:
+                        conn.execute(
+                            text(
+                                "ALTER TABLE installed_apps ADD COLUMN has_web_ui BOOLEAN DEFAULT 1 NOT NULL"
+                            )
+                        )
+                        conn.commit()
+                    if "settings_json" not in columns:
+                        conn.execute(
+                            text("ALTER TABLE installed_apps ADD COLUMN settings_json TEXT")
+                        )
+                        conn.commit()
+
+                if "users" in tables:
+                    user_cols = [c["name"] for c in inspector.get_columns("users")]
+                    if "last_login_at" not in user_cols:
+                        conn.execute(text("ALTER TABLE users ADD COLUMN last_login_at DATETIME"))
+                        conn.commit()
+                    if "last_active_at" not in user_cols:
+                        conn.execute(text("ALTER TABLE users ADD COLUMN last_active_at DATETIME"))
+                        conn.commit()
+                    if "login_count" not in user_cols:
+                        conn.execute(
+                            text(
+                                "ALTER TABLE users ADD COLUMN login_count INTEGER DEFAULT 0 NOT NULL"
+                            )
+                        )
+                        conn.commit()
+                    if "last_ip" not in user_cols:
+                        conn.execute(text("ALTER TABLE users ADD COLUMN last_ip VARCHAR(100)"))
+                        conn.commit()
+        except Exception as e:
+            print(f"[DB MIGRATION WARNING] Failed auto-migration check: {e}")
+
+        # Seed default system roles
+        try:
+            from appmanager.models import Role
+
+            if Role.query.count() == 0:
+                default_roles = [
+                    Role(
+                        name="Admin",
+                        slug="admin",
+                        description="System administrator with full permissions.",
+                        is_system=True,
+                    ),
+                    Role(
+                        name="User",
+                        slug="user",
+                        description="Standard member with assigned app permissions.",
+                        is_system=True,
+                    ),
+                    Role(
+                        name="Developer",
+                        slug="developer",
+                        description="Application developer with telemetry and API access.",
+                        is_system=False,
+                    ),
+                    Role(
+                        name="Manager",
+                        slug="manager",
+                        description="Team manager with supervisory access.",
+                        is_system=False,
+                    ),
+                    Role(
+                        name="Viewer",
+                        slug="viewer",
+                        description="Read-only access to authorized tools.",
+                        is_system=False,
+                    ),
+                ]
+                db.session.add_all(default_roles)
+                db.session.commit()
+        except Exception as e:
+            print(f"[DB INIT WARNING] Role seeding check: {e}")

appmanager/extension.py

@@ -0,0 +1,198 @@
+import os
+from typing import Any, List, Optional, Union
+
+from flask import Flask, redirect, render_template, url_for
+
+from appmanager.admin import admin_bp
+from appmanager.auth import auth_bp
+from appmanager.auth.utils import get_current_user
+from appmanager.config import Config
+from appmanager.database import db as default_db
+from appmanager.database import init_db
+from appmanager.extensions import init_extensions
+from appmanager.health import check_all_apps_health, check_app_health
+from appmanager.middleware import DynamicAppDispatcherMiddleware
+from appmanager.models import InstalledApp, UserAppPermission
+
+
+class AppManager:
+    """
+    Standard Flask extension class for AppManager.
+    Allows integrating AppManager into existing Flask applications or factory patterns.
+
+    Usage:
+        app = Flask(__name__)
+        manager = AppManager(app)
+        # or
+        manager = AppManager()
+        manager.init_app(app)
+    """
+
+    def __init__(
+        self,
+        app: Optional[Flask] = None,
+        db: Optional[Any] = None,
+        register_routes: bool = True,
+        register_blueprints: bool = True,
+    ) -> None:
+        self.app = app
+        self.db = db
+        self.register_routes = register_routes
+        self.register_blueprints = register_blueprints
+        self.dispatcher: Optional[DynamicAppDispatcherMiddleware] = None
+
+        if app is not None:
+            self.init_app(app, db=db)
+
+    def init_app(self, app: Flask, db: Optional[Any] = None) -> None:
+        """
+        Initializes the application with AppManager extension.
+        """
+        # Set default configs if not already set
+        for key in dir(Config):
+            if key.isupper() and key not in app.config:
+                app.config[key] = getattr(Config, key)
+
+        # Ensure base directories exist
+        base_dir = app.config.get("BASE_DIR", Config.BASE_DIR)
+        os.makedirs(app.config["INSTALLED_APPS_DIR"], exist_ok=True)
+        os.makedirs(app.config["TEMP_UPLOAD_DIR"], exist_ok=True)
+        os.makedirs(os.path.join(base_dir, "instance"), exist_ok=True)
+
+        # Initialize Database & Extension Helpers
+        init_db(app)
+        init_extensions(app)
+
+        # One-time migration: legacy settings_json → typed app_configs rows
+        try:
+            from appmanager.app_config import migrate_from_settings_json
+
+            migrate_from_settings_json()
+        except Exception:
+            pass
+
+        from appmanager.security import generate_csrf_token
+
+        app.jinja_env.globals["csrf_token"] = generate_csrf_token
+
+        # Register Blueprints
+        if self.register_blueprints:
+            from appmanager.api import api_bp
+
+            app.register_blueprint(auth_bp)
+
+            # Mount extension-declared admin blueprints onto admin_bp BEFORE it
+            # is registered on the app (admin auth enforced at mount time).
+            # Needs an app context for DB/manifest lookups.
+            try:
+                from appmanager.admin.registry import mount_all_app_admin_blueprints
+
+                with app.app_context():
+                    mount_all_app_admin_blueprints(admin_bp)
+            except Exception:
+                pass
+
+            app.register_blueprint(admin_bp)
+            app.register_blueprint(api_bp)
+
+        # Register Default Landing & Error Handlers if requested
+        if self.register_routes:
+            self._register_default_routes(app)
+
+        # Store extension instance on the Flask app
+        if not hasattr(app, "extensions"):
+            app.extensions = {}
+        app.extensions["appmanager"] = self
+
+    def _register_default_routes(self, app: Flask) -> None:
+        @app.route("/")
+        def index():
+            default_app = InstalledApp.query.filter_by(is_default=True, is_active=True).first()
+            if default_app:
+                if not default_app.requires_auth:
+                    return redirect(f"/apps/{default_app.slug}/")
+                user = get_current_user()
+                if not user:
+                    return redirect(url_for("auth.login", next=f"/apps/{default_app.slug}/"))
+                return redirect(f"/apps/{default_app.slug}/")
+            return redirect(url_for("dashboard"))
+
+        @app.route("/dashboard")
+        def dashboard():
+            user = get_current_user()
+            if not user:
+                return redirect(url_for("auth.login"))
+
+            if user.is_admin():
+                accessible_apps = InstalledApp.query.filter_by(is_active=True).all()
+            else:
+                accessible_apps = (
+                    default_db.session.query(InstalledApp)
+                    .join(UserAppPermission, UserAppPermission.app_id == InstalledApp.id)
+                    .filter(
+                        UserAppPermission.user_id == user.id,
+                        UserAppPermission.can_access.is_(True),
+                        InstalledApp.is_active.is_(True),
+                    )
+                    .all()
+                )
+            return render_template("index.html", user=user, apps=accessible_apps)
+
+        @app.errorhandler(404)
+        def not_found_error(error):
+            return render_template("errors/404.html", user=get_current_user()), 404
+
+        @app.errorhandler(500)
+        def internal_error(error):
+            return render_template("errors/500.html", user=get_current_user()), 500
+
+        @app.errorhandler(403)
+        def forbidden_error(error):
+            return render_template("errors/403.html", user=get_current_user()), 403
+
+        @app.errorhandler(401)
+        def unauthorized_error(error):
+            return render_template("errors/401.html", user=get_current_user()), 401
+
+    def create_dispatcher(self, app: Optional[Flask] = None) -> DynamicAppDispatcherMiddleware:
+        """
+        Wraps the Flask app with DynamicAppDispatcherMiddleware for sub-app routing.
+        """
+        target_app = app or self.app
+        if target_app is None:
+            raise ValueError("Flask app instance must be provided to create_dispatcher.")
+        self.dispatcher = DynamicAppDispatcherMiddleware(target_app)
+        return self.dispatcher
+
+    def clear_cache(self, slug: Optional[str] = None) -> None:
+        """
+        Clears the in-memory WSGI cache for a specific sub-app or all sub-apps.
+        """
+        if self.dispatcher:
+            self.dispatcher.clear_cache(slug=slug)
+
+    def get_app(self, slug: str) -> Optional[InstalledApp]:
+        """
+        Retrieve InstalledApp model instance by slug.
+        """
+        return InstalledApp.query.filter_by(slug=slug).first()
+
+    def get_apps(self, active_only: bool = True) -> List[InstalledApp]:
+        """
+        List installed sub-apps.
+        """
+        query = InstalledApp.query
+        if active_only:
+            query = query.filter_by(is_active=True)
+        return query.all()
+
+    def check_health(self, slug: Optional[str] = None) -> Union[List[Any], Any]:
+        """
+        Runs health check for a single sub-app by slug, or all active sub-apps if slug is None.
+        """
+        if slug:
+            app_record = self.get_app(slug)
+            if not app_record:
+                raise ValueError(f"App with slug '{slug}' not found.")
+            return check_app_health(app_record)
+        return check_all_apps_health()

appmanager/extensions.py

@@ -0,0 +1,225 @@
+import json
+import os
+import sys
+from datetime import datetime, timezone
+
+from markupsafe import Markup
+
+from appmanager.database import db
+from appmanager.hooks import hooks, render_slot
+from appmanager.models import AppExtensionData, InstalledApp
+
+
+def get_active_extensions(target_app_slug="appmanager"):
+    """
+    Returns active extension apps extending a specific target app.
+    """
+    return InstalledApp.query.filter_by(
+        app_type="extension", target_app=target_app_slug, is_active=True
+    ).all()
+
+
+def get_extension_data(extension_slug, entity_type, entity_id):
+    """
+    Retrieves stored JSON data dictionary for a specific extension & entity.
+    """
+    record = AppExtensionData.query.filter_by(
+        extension_slug=extension_slug, entity_type=entity_type, entity_id=entity_id
+    ).first()
+    if record and record.data_json:
+        try:
+            return json.loads(record.data_json)
+        except Exception:
+            return None
+    return None
+
+
+def set_extension_data(extension_slug, entity_type, entity_id, data_dict):
+    """
+    Stores or updates JSON data for a specific extension & entity.
+    """
+    record = AppExtensionData.query.filter_by(
+        extension_slug=extension_slug, entity_type=entity_type, entity_id=entity_id
+    ).first()
+    payload = json.dumps(data_dict) if data_dict is not None else None
+    if not record:
+        record = AppExtensionData(
+            extension_slug=extension_slug,
+            entity_type=entity_type,
+            entity_id=entity_id,
+            data_json=payload,
+        )
+        db.session.add(record)
+    else:
+        record.data_json = payload
+        record.updated_at = datetime.now(timezone.utc)
+    db.session.commit()
+    return record
+
+
+DEFAULT_PRESET_FLAIRS = [
+    {"title": "🚀 Lead Developer", "color": "#38bdf8"},
+    {"title": "⭐ VIP Member", "color": "#facc15"},
+    {"title": "🛡️ Moderator", "color": "#4ade80"},
+    {"title": "🔥 Core Contributor", "color": "#f87171"},
+    {"title": "💎 Sponsor", "color": "#c084fc"},
+]
+
+
+def _flairs_extension():
+    """
+    Import the User Flairs extension module if it is installed and active.
+    Returns None (graceful fallback) if unavailable.
+    """
+    try:
+        from appmanager.models import InstalledApp
+
+        rec = InstalledApp.query.filter_by(slug="extension-flairs", is_active=True).first()
+        if not rec:
+            return None
+        return _load_extension_module("extension-flairs", "extension")
+    except Exception:
+        return None
+
+
+def _load_extension_module(slug, module_name, installed_apps_dir=None):
+    """
+    Load an extension's module from its installed_apps directory.
+    Adds the extension dir to sys.path (idempotent) so top-level imports
+    like `import extension` / `import flairs_admin` resolve.
+    Returns the module, or None on failure.
+    """
+    try:
+        base = installed_apps_dir or os.path.join(
+            os.path.dirname(os.path.dirname(__file__)), "installed_apps"
+        )
+        ext_dir = os.path.join(base, slug)
+        if ext_dir not in sys.path:
+            sys.path.insert(0, ext_dir)
+        import importlib
+
+        return importlib.import_module(module_name)
+    except Exception:
+        return None
+
+
+def _register_extension_templates(app, slug):
+    """
+    Add an extension's `templates/` dir to the app's Jinja search path so its
+    blueprints can render their own templates. Idempotent; graceful on failure.
+    """
+    try:
+        base = app.config.get("INSTALLED_APPS_DIR")
+        tdir = os.path.join(base, slug, "templates")
+        if not os.path.isdir(tdir):
+            return
+        from jinja2 import ChoiceLoader, FileSystemLoader
+
+        loader = app.jinja_env.loader
+        if isinstance(loader, ChoiceLoader):
+            paths = [ldr.searchpath for ldr in loader.loaders if isinstance(ldr, FileSystemLoader)]
+            if tdir not in paths:
+                loader.loaders.append(FileSystemLoader(tdir))
+        else:
+            app.jinja_env.loader = ChoiceLoader([loader, FileSystemLoader(tdir)])
+    except Exception:
+        pass
+
+
+def get_user_flair(user_id):
+    """
+    Retrieves custom flair title and color for a user. Delegates to the
+    User Flairs extension if present; falls back to AppExtensionData.
+    """
+    mod = _flairs_extension()
+    if mod is not None and hasattr(mod, "get_user_flair"):
+        try:
+            return mod.get_user_flair(user_id)
+        except Exception:
+            pass
+    return get_extension_data("extension-flairs", "user", user_id)
+
+
+def set_user_flair(user_id, title, color="#a855f7"):
+    """
+    Sets or updates custom flair for a user. Delegates to the extension if present;
+    falls back to AppExtensionData.
+    """
+    mod = _flairs_extension()
+    if mod is not None and hasattr(mod, "set_user_flair"):
+        try:
+            return mod.set_user_flair(user_id, title, color)
+        except Exception:
+            pass
+    return set_extension_data("extension-flairs", "user", user_id, {"title": title, "color": color})
+
+
+def render_user_flair_badge(user_id):
+    """
+    Jinja helper rendering styled HTML flair badge for a user. Delegates to
+    the extension if present; falls back to AppExtensionData rendering.
+    """
+    mod = _flairs_extension()
+    if mod is not None and hasattr(mod, "render_user_flair_badge"):
+        try:
+            return mod.render_user_flair_badge(user_id)
+        except Exception:
+            pass
+    flair = get_user_flair(user_id)
+    if flair and flair.get("title"):
+        title = flair.get("title")
+        color = flair.get("color", "#38bdf8")
+        return Markup(
+            f'<span class="badge" style="background-color: {color}22; color: {color}; border: 1px solid {color}44; font-size: 0.75rem; padding: 2px 6px; border-radius: 4px; font-weight: 500; display: inline-flex; align-items: center; gap: 4px; margin-left: 6px;">'
+            f"{title}"
+            f"</span>"
+        )
+    return Markup("")
+
+
+def render_sparkline(health_logs):
+    """
+    Jinja helper rendering a braille sparkline from a list of AppHealthLog rows.
+    Each log maps to a braille char: healthy=high, degraded=mid, down=low.
+    """
+    if not health_logs:
+        return Markup("")
+    # Braille chars: low / mid / high
+    chars = {"healthy": "⣿", "degraded": "⣤", "down": "⣀"}
+    out = []
+    for log in health_logs:
+        status = getattr(log, "status", "") or ""
+        out.append(chars.get(status, "·"))
+    return Markup(
+        '<span class="sparkline" title="Health history (oldest → newest)">'
+        + "".join(out)
+        + "</span>"
+    )
+
+
+def init_extensions(app):
+    """
+    Registers Jinja helper functions and hook/slot integrations for extensions.
+    """
+    # Ensure the User Flairs extension dir is importable, then load it and
+    # let it register its own slots (user_badge). Graceful if unavailable.
+    mod = _load_extension_module(
+        "extension-flairs", "extension", app.config.get("INSTALLED_APPS_DIR")
+    )
+    if mod is not None and hasattr(mod, "register_slots"):
+        try:
+            mod.register_slots()
+        except Exception as e:
+            print(f"[EXTENSION] Failed to register slots for extension-flairs: {e}")
+
+    # Add the extension's templates dir to the app's template search path so
+    # its admin blueprint can render its own templates.
+    _register_extension_templates(app, "extension-flairs")
+
+    app.jinja_env.globals["get_user_flair"] = get_user_flair
+    app.jinja_env.globals["render_user_flair_badge"] = render_user_flair_badge
+    app.jinja_env.globals["get_active_extensions"] = get_active_extensions
+    app.jinja_env.globals["DEFAULT_PRESET_FLAIRS"] = DEFAULT_PRESET_FLAIRS
+    app.jinja_env.globals["render_slot"] = render_slot
+    app.jinja_env.globals["render_sparkline"] = render_sparkline
+    app.jinja_env.globals["hooks"] = hooks