appmanager-server 0.2.1__tar.gz → 0.3.1__tar.gz

appmanager_server-0.3.1/CHANGELOG.md

@@ -0,0 +1,59 @@
+# Changelog
+
+All notable changes to **`appmanager-server`** will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+---
+
+## [0.3.1] - 2026-08-28
+
+### Fixed
+- **App & Role Deletion Type-To-Confirm Modal**: Fixed modal validation logic and dynamic form URL in Admin Dashboard where typing the exact app/role slug did not enable the confirmation submission.
+
+---
+
+## [0.3.0] - 2026-08-28
+
+### Added
+- **Dependency & Environment Conflict Engine (`appmanager.dependency_manager`)**:
+  - Python runtime version verification comparing manifest `requires_python` against `platform.python_version()`.
+  - PEP 508 requirement analyzer checking active environment distributions for satisfied packages, packages to install, and conflicts against core host frameworks (`Flask`, `SQLAlchemy`, etc.).
+  - Shared dependency preservation analyzer protecting packages needed by other sub-apps when uninstalling.
+- **Configurable Virtual Environment Modes (`APP_VENV_MODE`)**:
+  - `"singular"` (Default): Single shared host environment.
+  - `"isolated"`: Per-app isolated virtual environment (`.venv/`).
+- **One-Click Sub-App Updates & Replacements**:
+  - Git Update action (`POST /admin/apps/<id>/update-git`) pulling remote changes with automated AST security scan, dependency sync, and cache reload.
+  - In-place ZIP replacement (`POST /admin/apps/<id>/precheck-replace-zip` -> `confirm-replace-zip`) with atomic rollback protection.
+- **CLI Commands**:
+  - `appmanager update <slug> [--zip <path>]`
+  - `appmanager check-deps [slug] [--all] [--install]`
+  - `appmanager install-deps [slug] [--all]`
+- **Nested AppManager Portals**: Support for nesting AppManager instances as sub-apps within parent AppManager instances with recursive dispatching.
+
+---
+
+## [0.2.1] - 2026-08-28
+
+### Added
+- **Configurable Dev Magic Login (`ALLOW_DEV_MAGIC_LOGIN`)**: Prevents showing one-click developer login buttons in production when SMTP is unconfigured unless explicitly permitted.
+- **Configurable Admin Role Provisioning (`ADMIN_EMAILS` & `FIRST_USER_IS_ADMIN`)**:
+  - `ADMIN_EMAILS`: Specify comma-separated list of admin email addresses.
+  - `FIRST_USER_IS_ADMIN`: Controls whether the very first registered user in a blank database receives the admin role (defaults to `true`).
+
+### Changed
+- Improved error messaging on `/auth/login` when SMTP is unconfigured.
+- Expanded authentication test suite.
+
+---
+
+## [0.2.0] - 2026-08-28
+
+### Added
+- Initial PyPI release under package name **`appmanager-server`**.
+- CLI commands and aliases: `appmanager-server`, `appmgr-server`, `appmanager`, and `appmgr`.
+- AST Security Scanner (`appmanager.security_scanner.SecurityScanner`) for ZIP and Git package pre-installation checks.
+- Python 3.10-3.13 support.
+- PyPI Trusted Publishing via GitHub Actions OIDC.

appmanager_server-0.3.1/MANIFEST.in

@@ -0,0 +1,17 @@
+include LICENSE
+include README.md
+include CHANGELOG.md
+include SECURITY.md
+include requirements.txt
+include .env.example
+graft appmanager/templates
+graft appmanager/static
+global-exclude __pycache__
+global-exclude *.py[cod]
+global-exclude .env*
+global-exclude *.db
+global-exclude *.sqlite*
+prune instance
+prune installed_apps
+prune .venv
+prune .pytest_cache

{appmanager_server-0.2.1 → appmanager_server-0.3.1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: appmanager-server
-Version: 0.2.1
-Summary: Multi-tenant Flask sub-application portal & dynamic WSGI dispatcher with in-process isolation, telemetry, and automated health checks.
+Version: 0.3.1
+Summary: High-performance multi-tenant WSGI portal, dynamic sub-app dispatcher, and extension framework for Python/Flask.
 Author: AppManager Contributors
 License: MIT
 Project-URL: Homepage, https://github.com/r3sbarra/appmanager-server
@@ -282,6 +282,11 @@ Available UI slots:
 | `appmanager dev <slug>` | Run standalone local test server with mock authentication |
 | `appmanager seed` | Seed database with default starter apps, roles, and flairs |
 | `appmanager new-subapp <name>` | Scaffold a sub-app with templates (`basic`, `api`, `extension`, `htmx`, `full`) |
+| `appmanager install-git <url>` | Install a sub-app from Git repository with security pre-check audit |
+| `appmanager install-zip <path>` | Install a sub-app from ZIP package with automated security pre-check |
+| `appmanager update <slug>` | One-click update for Git sub-apps or in-place replacement via `--zip <path>` |
+| `appmanager check-deps [slug]` | Inspect dependency health, Python version compatibility, and conflicts (`--all`, `--install`) |
+| `appmanager install-deps [slug]` | Automatically install declared requirements into single or isolated venv (`--all`) |
 | `appmanager validate-subapp <path>` | Validate a sub-app folder or ZIP package against manifest rules |
 | `appmanager export-app <slug>` | Package an installed sub-app into a deployable ZIP archive |
 | `appmanager reload-app <slug>` | Invalidate in-memory WSGI cache for zero-downtime updates |

{appmanager_server-0.2.1 → appmanager_server-0.3.1}/README.md

@@ -221,6 +221,11 @@ Available UI slots:
 | `appmanager dev <slug>` | Run standalone local test server with mock authentication |
 | `appmanager seed` | Seed database with default starter apps, roles, and flairs |
 | `appmanager new-subapp <name>` | Scaffold a sub-app with templates (`basic`, `api`, `extension`, `htmx`, `full`) |
+| `appmanager install-git <url>` | Install a sub-app from Git repository with security pre-check audit |
+| `appmanager install-zip <path>` | Install a sub-app from ZIP package with automated security pre-check |
+| `appmanager update <slug>` | One-click update for Git sub-apps or in-place replacement via `--zip <path>` |
+| `appmanager check-deps [slug]` | Inspect dependency health, Python version compatibility, and conflicts (`--all`, `--install`) |
+| `appmanager install-deps [slug]` | Automatically install declared requirements into single or isolated venv (`--all`) |
 | `appmanager validate-subapp <path>` | Validate a sub-app folder or ZIP package against manifest rules |
 | `appmanager export-app <slug>` | Package an installed sub-app into a deployable ZIP archive |
 | `appmanager reload-app <slug>` | Invalidate in-memory WSGI cache for zero-downtime updates |

{appmanager_server-0.2.1 → appmanager_server-0.3.1}/appmanager/__init__.py

@@ -8,7 +8,7 @@ from appmanager.database import db
 from appmanager.extension import AppManager
 from appmanager.middleware import DynamicAppDispatcherMiddleware
 
-__version__ = "0.2.1"
+__version__ = "0.3.1"
 
 __all__ = [
     "AppManager",

{appmanager_server-0.2.1 → appmanager_server-0.3.1}/appmanager/admin/app_installer.py

@@ -1,6 +1,8 @@
 import ast
 import importlib.util
+import inspect
 import json
+import logging
 import os
 import shutil
 import subprocess
@@ -14,6 +16,12 @@ from flask import current_app
 from werkzeug.utils import secure_filename
 
 from appmanager.database import db
+from appmanager.dependency_manager import (
+    DependencyAnalysisReport,
+    analyze_dependencies,
+    analyze_uninstall_dependencies,
+    install_app_dependencies,
+)
 from appmanager.models import InstalledApp, User, UserAppPermission
 from appmanager.security import (
     extract_zip_safely,
@@ -21,7 +29,9 @@ from appmanager.security import (
     validate_entrypoint_path,
 )
 from appmanager.security_scanner import SecurityScanReport, run_security_scan
-from appmanager.signals import subapp_installed, subapp_uninstalled
+from appmanager.signals import subapp_installed, subapp_reloaded, subapp_uninstalled, subapp_updated
+
+logger = logging.getLogger("appmanager.installer")
 
 
 def sanitize_slug(slug_text: str) -> str:
@@ -210,32 +220,51 @@ def validate_subapp_package(path_or_zip: str) -> Tuple[bool, List[str], Dict[str
 
 def discover_entrypoint(app_dir: str) -> str:
     """
-    Search for common Flask entrypoint files (app.py, wsgi.py, main.py, run.py) or manifest.json.
-    Returns 'module_name:app_variable' string e.g. 'app:app'
+    Search for common Flask entrypoint files (app.py, wsgi.py, main.py, run.py, src/app.py, packages)
+    or manifest.json. Returns 'module_name:app_variable' string e.g. 'app:app'
     """
     manifest = parse_manifest(app_dir)
     if manifest and "entry_point" in manifest:
         return manifest["entry_point"]
 
-    candidates = ["app.py", "wsgi.py", "main.py", "run.py"]
+    candidates = [
+        "app.py",
+        "wsgi.py",
+        "main.py",
+        "run.py",
+        "server.py",
+        os.path.join("src", "app.py"),
+        os.path.join("src", "main.py"),
+        os.path.join("src", "wsgi.py"),
+    ]
     for candidate in candidates:
         if os.path.exists(os.path.join(app_dir, candidate)):
-            module_name = candidate[:-3]  # Strip .py
+            module_name = candidate[:-3].replace(os.sep, ".")  # Strip .py and normalize slashes
             return f"{module_name}:app"
 
+    # Check for package directories with __init__.py (e.g. appmanager, app, <slug>)
+    slug = os.path.basename(app_dir.rstrip("/\\"))
+    for pkg_cand in [slug, slug.replace("-", "_"), "app", "appmanager"]:
+        init_file = os.path.join(app_dir, pkg_cand, "__init__.py")
+        if os.path.exists(init_file):
+            return f"{pkg_cand}:create_app"
+
     # Default fallback
     return "app:app"
 
 
-def install_dependencies(app_dir: str) -> None:
-    req_file = os.path.join(app_dir, "requirements.txt")
-    if os.path.exists(req_file):
-        try:
-            print(f"[INSTALLER] Installing dependencies for sub-app at {app_dir}...")
-            subprocess.check_call([sys.executable, "-m", "pip", "install", "-r", req_file])
-            print("[INSTALLER] Sub-app dependencies installed successfully.")
-        except Exception as e:
-            print(f"[INSTALLER WARNING] Failed to install requirements.txt: {e}")
+def install_dependencies(app_dir: str) -> Tuple[bool, str]:
+    """
+    Installs sub-app dependencies using the configured virtual environment mode (singular or isolated).
+    """
+    venv_mode = "singular"
+    if current_app:
+        venv_mode = current_app.config.get("APP_VENV_MODE", "singular")
+
+    ok, msg = install_app_dependencies(app_dir, venv_mode=venv_mode)
+    if not ok:
+        print(f"[INSTALLER WARNING] {msg}")
+    return ok, msg
 
 
 def load_wsgi_app_from_path(app_dir: str, entry_point: str = "app:app") -> Any:
@@ -253,7 +282,9 @@ def load_wsgi_app_from_path(app_dir: str, entry_point: str = "app:app") -> Any:
 
     module_path = module_path_or_err
     if not os.path.exists(module_path):
-        raise FileNotFoundError(f"Entrypoint file '{module_name}.py' not found in {app_dir}")
+        raise FileNotFoundError(
+            f"Entrypoint module/file '{module_name}' was not found in sub-app package."
+        )
 
     # Unique scoped module spec name to avoid sys.path pollution
     slug = os.path.basename(app_dir)
@@ -267,15 +298,37 @@ def load_wsgi_app_from_path(app_dir: str, entry_point: str = "app:app") -> Any:
     sys.modules[scoped_module_name] = mod
     spec.loader.exec_module(mod)
 
-    # Check for Flask app instance or callable create_app factory
+    # Check for Flask app instance, callable create_app factory, or WSGI middleware
     if hasattr(mod, app_var_name):
         app_obj = getattr(mod, app_var_name)
-        if callable(app_obj) and not hasattr(app_obj, "wsgi_app"):
-            # Factory function e.g. create_app()
-            app_instance = app_obj()
-        else:
-            app_instance = app_obj
-        return app_instance
+        if hasattr(app_obj, "wsgi_app"):
+            return app_obj
+
+        if callable(app_obj):
+            if inspect.isfunction(app_obj) or inspect.ismethod(app_obj):
+                try:
+                    sig = inspect.signature(app_obj)
+                    params = list(sig.parameters.values())
+                    # Standard WSGI callable: (environ, start_response)
+                    if len(params) == 2 and params[0].name in ("environ", "env"):
+                        return app_obj
+                    required_params = [
+                        p
+                        for p in params
+                        if p.default == inspect.Parameter.empty
+                        and p.kind
+                        in (
+                            inspect.Parameter.POSITIONAL_ONLY,
+                            inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                        )
+                    ]
+                    if len(required_params) == 0:
+                        return app_obj()
+                except Exception:
+                    pass
+            return app_obj
+
+        return app_obj
 
     raise AttributeError(f"Module '{module_name}' in {app_dir} does not export '{app_var_name}'")
 
@@ -289,10 +342,14 @@ def _write_staging_metadata(staging_dir: str, meta: Dict[str, Any]) -> None:
     """Saves staging session metadata to disk inside the sandboxed staging directory."""
     meta_path = os.path.join(staging_dir, "_staging_meta.json")
     try:
-        # Don't serialize scan_report object directly to JSON if it's an object
+        # Don't serialize scan_report / dependency_report object directly to JSON if it's an object
         serializable = dict(meta)
         if "scan_report" in serializable and hasattr(serializable["scan_report"], "to_dict"):
             serializable["scan_report"] = serializable["scan_report"].to_dict()
+        if "dependency_report" in serializable and hasattr(
+            serializable["dependency_report"], "to_dict"
+        ):
+            serializable["dependency_report"] = serializable["dependency_report"].to_dict()
         with open(meta_path, "w", encoding="utf-8") as f:
             json.dump(serializable, f)
     except Exception as e:
@@ -366,6 +423,7 @@ def stage_git_repo(
     if not is_safe_repo_url(repo_url):
         raise ValueError(f"Invalid or unsafe git repository URL: '{repo_url}'")
 
+    logger.info("Staging Git repository installation from '%s'", repo_url)
     cleanup_expired_staged_sessions()
 
     import tempfile
@@ -390,6 +448,7 @@ def stage_git_repo(
                     res.stderr.strip() or f"Failed to clone repository from '{repo_url}'."
                 )
     except Exception as git_err:
+        logger.error("Failed to clone Git repository '%s': %s", repo_url, git_err)
         if os.path.exists(temp_stage_dir):
             shutil.rmtree(temp_stage_dir, ignore_errors=True)
         raise ValueError(f"Failed to clone Git repository: {git_err}")
@@ -417,6 +476,10 @@ def stage_git_repo(
     # Run static security pre-check
     scan_report = run_security_scan(temp_stage_dir)
 
+    # Run dependency analysis
+    venv_mode = current_app.config.get("APP_VENV_MODE", "singular") if current_app else "singular"
+    dep_report = analyze_dependencies(temp_stage_dir, manifest=manifest, venv_mode=venv_mode)
+
     _staged_installations[staging_id] = {
         "staging_id": staging_id,
         "staging_dir": temp_stage_dir,
@@ -427,9 +490,17 @@ def stage_git_repo(
         "entry_point": resolved_entry_point,
         "manifest": manifest,
         "scan_report": scan_report,
+        "dependency_report": dep_report,
         "created_at": time.time(),
     }
     _write_staging_metadata(temp_stage_dir, _staged_installations[staging_id])
+    logger.info(
+        "Staged Git app '%s' (staging_id=%s, risk=%s, safe=%s)",
+        resolved_slug,
+        staging_id,
+        scan_report.risk_level,
+        scan_report.is_safe,
+    )
 
     return staging_id, scan_report, manifest
 
@@ -494,6 +565,10 @@ def stage_zip_file(
     # Run static security pre-check
     scan_report = run_security_scan(temp_stage_dir)
 
+    # Run dependency analysis
+    venv_mode = current_app.config.get("APP_VENV_MODE", "singular") if current_app else "singular"
+    dep_report = analyze_dependencies(temp_stage_dir, manifest=manifest, venv_mode=venv_mode)
+
     _staged_installations[staging_id] = {
         "staging_id": staging_id,
         "staging_dir": temp_stage_dir,
@@ -504,9 +579,17 @@ def stage_zip_file(
         "entry_point": resolved_entry_point,
         "manifest": manifest,
         "scan_report": scan_report,
+        "dependency_report": dep_report,
         "created_at": time.time(),
     }
     _write_staging_metadata(temp_stage_dir, _staged_installations[staging_id])
+    logger.info(
+        "Staged ZIP package '%s' (filename: %s, risk=%s, safe=%s)",
+        resolved_slug,
+        filename,
+        scan_report.risk_level,
+        scan_report.is_safe,
+    )
 
     return staging_id, scan_report, manifest
 
@@ -535,6 +618,7 @@ def finalize_staged_installation(
 
     final_slug = sanitize_slug(slug or session.get("slug") or session.get("name") or "sub-app")
     target_dir = os.path.join(current_app.config["INSTALLED_APPS_DIR"], final_slug)
+    logger.info("Finalizing installation of staged app '%s' into '%s'", final_slug, target_dir)
 
     if os.path.exists(target_dir):
         if os.path.exists(staging_dir):
@@ -585,6 +669,7 @@ def finalize_staged_installation(
             else:
                 initial_settings[s_key] = s_val
 
+    logger.info("Installing dependencies for '%s'...", final_slug)
     install_dependencies(target_dir)
 
     installed_app = InstalledApp(
@@ -707,13 +792,267 @@ def export_app_to_zip(slug: str, output_path: Optional[str] = None) -> str:
     return output_path
 
 
+def update_app_from_git(app_id_or_slug: Any) -> Tuple[bool, str, Dict[str, Any]]:
+    """
+    Pulls latest commits from remote Git repository for an installed app, executes
+    AST security pre-check audit on updated files, updates dependencies, and reloads WSGI cache.
+    """
+    if isinstance(app_id_or_slug, int) or (
+        isinstance(app_id_or_slug, str) and app_id_or_slug.isdigit()
+    ):
+        app_record = db.session.get(InstalledApp, int(app_id_or_slug))
+    else:
+        app_record = InstalledApp.query.filter_by(slug=str(app_id_or_slug)).first()
+
+    if not app_record:
+        return False, "Application not found in database.", {}
+
+    slug = app_record.slug
+    app_dir = os.path.join(current_app.config["INSTALLED_APPS_DIR"], slug)
+
+    if not os.path.exists(app_dir):
+        return False, f"App directory for '{app_record.name}' does not exist on disk.", {}
+
+    git_dir = os.path.join(app_dir, ".git")
+    if not os.path.exists(git_dir):
+        return (
+            False,
+            f"'{app_record.name}' was not installed via Git (no .git directory found).",
+            {},
+        )
+
+    # 1. Fetch and pull changes
+    try:
+        # Fetch remote refs
+        fetch_res = subprocess.run(
+            ["git", "fetch", "origin"],
+            cwd=app_dir,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        if fetch_res.returncode != 0:
+            return False, f"Git fetch failed: {fetch_res.stderr.strip()}", {}
+
+        # Reset / pull to origin HEAD
+        pull_res = subprocess.run(
+            ["git", "pull", "--ff-only"],
+            cwd=app_dir,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        if pull_res.returncode != 0:
+            # Fallback to merge or pull origin HEAD
+            pull_res = subprocess.run(
+                ["git", "pull", "origin", "HEAD"],
+                cwd=app_dir,
+                capture_output=True,
+                text=True,
+                timeout=60,
+            )
+            if pull_res.returncode != 0:
+                return False, f"Git pull failed: {pull_res.stderr.strip()}", {}
+
+    except Exception as git_err:
+        return False, f"Git operation error: {str(git_err)}", {}
+
+    # 2. Run AST Security Scan on updated repository
+    scan_report = run_security_scan(app_dir)
+    if not scan_report.is_safe:
+        return (
+            False,
+            f"Security scan failed on updated code: {scan_report.summary}",
+            {"scan_report": scan_report.to_dict()},
+        )
+
+    # 3. Analyze and install dependencies
+    venv_mode = current_app.config.get("APP_VENV_MODE", "singular") if current_app else "singular"
+    manifest = parse_manifest(app_dir) or {}
+    dep_report = analyze_dependencies(app_dir, manifest=manifest, venv_mode=venv_mode)
+
+    dep_ok, dep_msg = install_dependencies(app_dir)
+
+    # 4. Update InstalledApp metadata
+    if manifest:
+        if manifest.get("name"):
+            app_record.name = manifest["name"]
+        if manifest.get("description"):
+            app_record.description = manifest["description"]
+        if manifest.get("entry_point"):
+            app_record.entry_point = manifest["entry_point"]
+
+    db.session.commit()
+
+    # 5. Clear WSGI cache and trigger signals
+    if hasattr(current_app, "extensions") and "appmanager" in current_app.extensions:
+        current_app.extensions["appmanager"].clear_cache(slug=slug)
+
+    try:
+        subapp_reloaded.send(None, slug=slug)
+        subapp_updated.send(None, app_slug=slug, app_id=app_record.id, update_type="git")
+    except Exception:
+        pass
+
+    try:
+        from appmanager.hooks import trigger_hook
+
+        trigger_hook("on_app_updated", app_id=app_record.id, app_slug=slug, update_type="git")
+    except Exception:
+        pass
+
+    return (
+        True,
+        f"Application '{app_record.name}' updated successfully from Git.",
+        {
+            "scan_report": scan_report.to_dict(),
+            "dependency_report": dep_report.to_dict(),
+            "dep_output": dep_msg,
+            "manifest": manifest,
+        },
+    )
+
+
+def stage_zip_replacement(
+    app_id_or_slug: Any,
+    zip_file_storage: Any,
+) -> Tuple[str, SecurityScanReport, Dict[str, Any], DependencyAnalysisReport]:
+    """
+    Stages an uploaded ZIP file for replacing an existing installed application.
+    """
+    if isinstance(app_id_or_slug, int) or (
+        isinstance(app_id_or_slug, str) and app_id_or_slug.isdigit()
+    ):
+        app_record = db.session.get(InstalledApp, int(app_id_or_slug))
+    else:
+        app_record = InstalledApp.query.filter_by(slug=str(app_id_or_slug)).first()
+
+    if not app_record:
+        raise ValueError("Target application to replace was not found.")
+
+    staging_id, scan_report, manifest = stage_zip_file(
+        zip_file_storage=zip_file_storage,
+        name=app_record.name,
+        slug=app_record.slug,
+        entry_point=app_record.entry_point,
+    )
+
+    session = _staged_installations[staging_id]
+    session["action"] = "replace"
+    session["target_app_id"] = app_record.id
+    _write_staging_metadata(session["staging_dir"], session)
+
+    dep_report = session["dependency_report"]
+    return staging_id, scan_report, manifest, dep_report
+
+
+def finalize_zip_replacement(staging_id: str) -> InstalledApp:
+    """
+    Finalizes replacing an existing app's files with newly staged ZIP archive contents.
+    """
+    session = get_staged_session(staging_id)
+    if not session:
+        raise ValueError(f"Staged session '{staging_id}' not found or expired.")
+
+    _staged_installations.pop(staging_id, None)
+
+    staging_dir = session["staging_dir"]
+    target_app_id = session.get("target_app_id")
+    target_slug = session.get("slug")
+
+    if target_app_id:
+        app_record = db.session.get(InstalledApp, target_app_id)
+    else:
+        app_record = InstalledApp.query.filter_by(slug=target_slug).first()
+
+    if not app_record:
+        if os.path.exists(staging_dir):
+            shutil.rmtree(staging_dir, ignore_errors=True)
+        raise ValueError("Target app to replace was not found.")
+
+    target_dir = os.path.join(current_app.config["INSTALLED_APPS_DIR"], app_record.slug)
+
+    # Atomically replace target directory
+    temp_backup_dir = None
+    try:
+        import tempfile
+
+        if os.path.exists(target_dir):
+            temp_backup_dir = tempfile.mkdtemp(prefix="app_backup_")
+            # Move existing app out
+            for item in os.listdir(target_dir):
+                s = os.path.join(target_dir, item)
+                d = os.path.join(temp_backup_dir, item)
+                shutil.move(s, d)
+
+        # Move new staged files in
+        meta_path = os.path.join(staging_dir, "_staging_meta.json")
+        if os.path.exists(meta_path):
+            try:
+                os.remove(meta_path)
+            except Exception:
+                pass
+
+        for item in os.listdir(staging_dir):
+            s = os.path.join(staging_dir, item)
+            d = os.path.join(target_dir, item)
+            shutil.move(s, d)
+
+        if os.path.exists(staging_dir):
+            shutil.rmtree(staging_dir, ignore_errors=True)
+
+        if temp_backup_dir and os.path.exists(temp_backup_dir):
+            shutil.rmtree(temp_backup_dir, ignore_errors=True)
+
+    except Exception as e:
+        if temp_backup_dir and os.path.exists(temp_backup_dir) and os.path.exists(target_dir):
+            # Restore backup on failure
+            shutil.rmtree(target_dir, ignore_errors=True)
+            os.makedirs(target_dir, exist_ok=True)
+            for item in os.listdir(temp_backup_dir):
+                shutil.move(os.path.join(temp_backup_dir, item), os.path.join(target_dir, item))
+            shutil.rmtree(temp_backup_dir, ignore_errors=True)
+        raise RuntimeError(f"Failed to replace application files: {e}")
+
+    # Update dependencies and manifest
+    install_dependencies(target_dir)
+
+    manifest = parse_manifest(target_dir) or {}
+    if manifest:
+        if manifest.get("name"):
+            app_record.name = manifest["name"]
+        if manifest.get("description"):
+            app_record.description = manifest["description"]
+        if manifest.get("entry_point"):
+            app_record.entry_point = manifest["entry_point"]
+
+    db.session.commit()
+
+    # Clear cache and trigger reload
+    if hasattr(current_app, "extensions") and "appmanager" in current_app.extensions:
+        current_app.extensions["appmanager"].clear_cache(slug=app_record.slug)
+
+    try:
+        subapp_reloaded.send(None, slug=app_record.slug)
+        subapp_updated.send(None, app_slug=app_record.slug, app_id=app_record.id, update_type="zip")
+    except Exception:
+        pass
+
+    return app_record
+
+
 def uninstall_app(app_id: int) -> Tuple[bool, str]:
     app_record = db.session.get(InstalledApp, app_id)
     if not app_record:
         return False, "App not found."
 
     slug = app_record.slug
-    target_dir = os.path.join(current_app.config["INSTALLED_APPS_DIR"], slug)
+    installed_apps_dir = current_app.config["INSTALLED_APPS_DIR"]
+    target_dir = os.path.join(installed_apps_dir, slug)
+
+    # 1. Analyze dependencies to preserve shared packages
+    dep_summary = analyze_uninstall_dependencies(slug, installed_apps_dir)
+
     if os.path.exists(target_dir):
         shutil.rmtree(target_dir, ignore_errors=True)
 
@@ -736,4 +1075,7 @@ def uninstall_app(app_id: int) -> Tuple[bool, str]:
     except Exception:
         pass
 
-    return True, "App uninstalled successfully."
+    preserved_msg = (
+        f" ({dep_summary['message']})" if dep_summary.get("shared_packages_preserved") else ""
+    )
+    return True, f"Application '{app_record.name}' uninstalled successfully.{preserved_msg}"