ARES - authorized red-team engagement automation with dashboard, campaign scope, module orchestration, OPSEC controls, encrypted vault, and reporting.
Python active-directorycloud-securitydefensive-validationfastapigood-first-issuemitre-attackopsecreactred-teamreportingsecurity
feat(updater): implement secure nuclei-style platform update and upgrade commands
Mafifrizi527a91f6e62f
diff --git a/README.md b/README.mdindex 84a4f6c..812dc3e 100644--- a/README.md+++ b/README.md@@ -512,6 +512,27 @@ Open your browser to **`http://127.0.0.1:5173/dashboard/`**.- **Initial Operator**: `admin`- **Initial Password**: Configured via `ARES_DEFAULT_ADMIN_PASSWORD` in `.env` (default: `Admin123456!`)+### Seamless Platform Updates & In-Place Upgrades (`ares update` & `ares upgrade`)++ARES includes a built-in Nuclei-style update engine. Operators do not need to `git clone` or manually recompile the frontend when new capabilities or visual improvements are released:++- **Add New Attack Modules (Additive Only)**:+ ```powershell+ ares update # Scan GitHub and install newly released modules+ ares update --module <id> # Install a specific new module+ ares update --dry-run # Preview new modules without modifying disk+ ```+- **In-Place Upgrades (Existing Modules, Web UI, Full Platform)**:+ ```powershell+ ares upgrade --all # Upgrade full platform (modules + Web UI + engine)+ ares upgrade --ui # Upgrade Frontend Web UI dashboard bundle+ ares upgrade --modules # Upgrade installed modules to latest revisions+ ares upgrade --dry-run # Preview upgrades without modifying disk+ ```++> [!NOTE]+> **Zero Data Loss Guarantee**: User databases (`~/.ares/ares.db` or PostgreSQL), credentials, configuration files (`config.yaml`), audit reports, and custom user plugins (`~/.ares/plugins/`) are mathematically blacklisted from modification. Pre-flight Python AST verification and atomic file writes ensure zero risk of corruption.+---## Enterprise Security Model & Compliancediff --git a/ares/api/server.py b/ares/api/server.pyindex 2646525..0e9ccde 100644--- a/ares/api/server.py+++ b/ares/api/server.py@@ -2209,6 +2209,46 @@ async def list_modules(return enriched[email protected]("/modules/reload", tags=["modules"])+async def reload_modules(+ request: Request,+ engine: AresEngine = Depends(get_engine),+) -> dict[str, Any]:+ """+ Reload plugin registry in-memory from builtin and external module sources.+ Security: Strictly permitted for loopback origins (127.0.0.1, ::1, testclient)+ or authenticated operators with write/admin privileges.+ """+ import importlib++ client_host = request.client.host if request.client else "127.0.0.1"+ is_loopback = client_host in ("127.0.0.1", "::1", "localhost", "testclient")++ if not is_loopback:+ auth_hdr = request.headers.get("Authorization") or request.headers.get("X-API-Key")+ if not auth_hdr:+ raise HTTPException(+ status_code=403,+ detail="Remote module reload requires operator authorization.",+ )+ try:+ _ = await require_operator()(request)+ except Exception as exc:+ raise HTTPException(+ status_code=403,+ detail="Insufficient permissions for module reload.",+ ) from exc++ importlib.invalidate_caches()+ count = engine.load_modules()+ logger.info("engine_modules_reloaded", total_modules=count, client=client_host)+ return {+ "status": "ok",+ "reloaded": True,+ "module_count": count,+ }++@app.get("/modules/execution-chains", tags=["modules"])async def list_execution_chains(actor: AuthenticatedUser = _api_key_read_dep,diff --git a/ares/cli/typer_main.py b/ares/cli/typer_main.pyindex 8bd10ef..61a40a0 100644--- a/ares/cli/typer_main.py+++ b/ares/cli/typer_main.py@@ -2298,12 +2298,173 @@ def backup(try:out = asyncio.run(_run())- console.print(f"[green]✅ Backup saved:[/green] {out}")+ console.print(f"[green][+] Backup saved:[/green] {out}")except Exception as exc:- console.print(f"[red]❌ Backup failed: {exc}[/red]")+ console.print(f"[red][-] Backup failed: {exc}[/red]")raise typer.Exit(1)+# ── update command (Additive new modules) ─────────────────────────────────────+[email protected]("update")+def update_cmd(+ module: Optional[str] = typer.Option(None, "--module", "-m", help="Specific new module ID to install"),+ dry_run: bool = typer.Option(False, "--dry-run", help="Preview new modules without downloading"),+ repo: str = typer.Option("Mafifrizi/ARES", "--repo", help="Official GitHub repository (owner/repo)"),+ branch: str = typer.Option("main", "--branch", help="Git branch to synchronize against"),+) -> None:+ """+ Synchronize and install newly released ARES attack modules (additive only).++ This command only fetches new modules that you do not already possess.+ Existing modules, user configuration, and database files remain untouched.+ """+ from ares.core.updater import PlatformUpdateManager++ console.print(Panel.fit(+ "[bold cyan]ARES Module Update Engine[/bold cyan]\n"+ f"Target: [green]{repo}@{branch}[/green] | Mode: [yellow]{'Dry-Run' if dry_run else 'Additive Install'}[/yellow]",+ border_style="cyan",+ ))++ mgr = PlatformUpdateManager(github_repo=repo, branch=branch)++ try:+ with console.status("[cyan]Checking remote repository for new attack modules...[/cyan]"):+ check_res = mgr.check_updates()+ except Exception as exc:+ console.print(f"[red][-] Update check failed: {exc}[/red]")+ raise typer.Exit(1)++ new_mods = check_res.new_modules+ if module:+ cleaned = module.strip().lower()+ new_mods = [m for m in new_mods if m.module_id.lower() == cleaned or m.relative_path.lower().endswith(f"{cleaned}.py")]++ if not new_mods:+ console.print("[green][+] All official modules are already installed. No new modules available.[/green]")+ console.print(f"[dim]Total local modules: {check_res.local_count} | Remote catalog: {check_res.remote_count}[/dim]")+ if check_res.upgradable_modules:+ console.print("[yellow][*] Note: Existing modules have revisions available. Run 'ares upgrade --modules' to update them.[/yellow]")+ return++ table = Table(title="New Modules Available for Installation", box=box.ROUNDED)+ table.add_column("Module ID", style="cyan bold")+ table.add_column("Category", style="green")+ table.add_column("Relative Path", style="dim")+ table.add_column("Size", style="yellow")++ for item in new_mods:+ table.add_row(item.module_id, item.category or "general", item.relative_path, f"{item.size_bytes} B")+ console.print(table)++ if dry_run:+ console.print(f"\n[yellow][*] Dry-run complete. {len(new_mods)} new module(s) can be installed with 'ares update'.[/yellow]")+ return++ console.print(f"\n[cyan][*] Installing {len(new_mods)} new module(s)...[/cyan]")+ res = mgr.update_modules(module_id=module, dry_run=False)++ if res.get("status") == "ok":+ console.print(f"[green][+] Successfully installed {res.get('installed_count')} new module(s).[/green]")+ for mod in res.get("installed_modules", []):+ console.print(f" [green]+[/green] {mod}")+ else:+ console.print(f"[yellow][!] Installed {res.get('installed_count')} module(s) with errors:[/yellow]")+ for err in res.get("errors", []):+ console.print(f" [red]-[/red] {err}")+++# ── upgrade command (In-place patches, UI dashboard, full platform) ───────────+[email protected]("upgrade")+def upgrade_cmd(+ all: bool = typer.Option(False, "--all", "-a", help="Upgrade full platform (modules + Web UI + engine)"),+ ui: bool = typer.Option(False, "--ui", help="Upgrade Frontend Web UI Dashboard bundle"),+ modules: bool = typer.Option(False, "--modules", help="Upgrade existing attack modules to latest versions"),+ module: Optional[str] = typer.Option(None, "--module", "-m", help="Specific installed module ID to upgrade"),+ dry_run: bool = typer.Option(False, "--dry-run", help="Preview upgrades without modifying disk"),+ repo: str = typer.Option("Mafifrizi/ARES", "--repo", help="Official GitHub repository (owner/repo)"),+ branch: str = typer.Option("main", "--branch", help="Git branch to synchronize against"),+) -> None:+ """+ Upgrade existing ARES modules, Web UI dashboard, or the entire platform.++ Ensures zero data loss: Databases, credentials, and custom configurations are preserved.+ """+ from ares.core.updater import PlatformUpdateManager++ # Default to --all if no specific scope is selected+ if not all and not ui and not modules and not module:+ all = True++ action_label = "Full Platform" if all else ("Web UI Dashboard" if ui and not modules else "Attack Modules")++ console.print(Panel.fit(+ "[bold cyan]ARES Platform Upgrade Engine[/bold cyan]\n"+ f"Target: [green]{repo}@{branch}[/green] | Scope: [bold]{action_label}[/bold] | Mode: [yellow]{'Dry-Run' if dry_run else 'In-Place Upgrade'}[/yellow]",+ border_style="cyan",+ ))++ mgr = PlatformUpdateManager(github_repo=repo, branch=branch)++ if all:+ with console.status("[cyan]Upgrading complete platform (modules, Web UI, hot-reload)...[/cyan]"):+ res = mgr.upgrade_all(dry_run=dry_run)+ if dry_run:+ console.print("[yellow][*] Dry-run simulation completed. No files modified.[/yellow]")+ return+ console.print("[green][+] Full platform upgrade completed successfully.[/green]")+ console.print(f" - Modules updated: [cyan]{res.get('modules_upgraded', 0)}[/cyan]")+ console.print(f" - New modules added: [cyan]{res.get('modules_added', 0)}[/cyan]")+ console.print(f" - Web UI status: [cyan]{res.get('ui_status', 'ok')}[/cyan]")+ srv = res.get("server_reload", {})+ if srv.get("connected"):+ console.print(f" - Live Server Hot-Reload: [green]Connected ({srv.get('module_count')} modules active)[/green]")+ else:+ console.print(" - Live Server: [dim]Offline (changes will apply on next start)[/dim]")+ return++ if ui:+ with console.status("[cyan]Upgrading Frontend Web UI Dashboard bundle...[/cyan]"):+ try:+ res = mgr.upgrade_ui(dry_run=dry_run)+ if dry_run:+ console.print(f"[yellow][*] {res.get('message')}[/yellow]")+ else:+ console.print(f"[green][+] {res.get('message')}[/green]")+ console.print(f"[dim]Distribution path: {res.get('target_dir')}[/dim]")+ except Exception as exc:+ console.print(f"[red][-] UI upgrade failed: {exc}[/red]")+ raise typer.Exit(1)+ if not modules and not module:+ return++ if modules or module:+ with console.status("[cyan]Checking and upgrading attack modules...[/cyan]"):+ try:+ res = mgr.upgrade_modules(module_id=module, dry_run=dry_run)+ except Exception as exc:+ console.print(f"[red][-] Module upgrade failed: {exc}[/red]")+ raise typer.Exit(1)++ if dry_run:+ console.print(f"[yellow][*] Dry-run complete. {res.get('upgraded_count', 0)} module(s) eligible for upgrade.[/yellow]")+ return++ if res.get("status") == "ok":+ console.print(f"[green][+] Successfully upgraded {res.get('upgraded_count', 0)} module(s).[/green]")+ for mod in res.get("upgraded_modules", []):+ console.print(f" [green]*[/green] {mod}")+ elif res.get("status") == "not_found":+ console.print(f"[yellow][!] {res.get('message')}[/yellow]")+ else:+ console.print(f"[yellow][!] Upgraded with warnings:[/yellow]")+ for err in res.get("errors", []):+ console.print(f" [red]-[/red] {err}")+++# ── Goal commands ──────────────────────────────────────────────────────────────diff --git a/ares/core/plugin/loader.py b/ares/core/plugin/loader.pyindex c07d617..1c9360c 100644--- a/ares/core/plugin/loader.py+++ b/ares/core/plugin/loader.py@@ -355,7 +355,13 @@ class PluginLoader:def _import_and_register(self, module_path: str, source: str) -> None:try:- mod = importlib.import_module(module_path)+ if module_path in sys.modules:+ try:+ mod = importlib.reload(sys.modules[module_path])+ except Exception:+ mod = importlib.import_module(module_path)+ else:+ mod = importlib.import_module(module_path)for _, cls in inspect.getmembers(mod, inspect.isclass):if self._is_valid_module_class(cls):self.registry.register(cls, source=source)diff --git a/ares/core/updater.py b/ares/core/updater.pynew file mode 100644index 0000000..8723dea--- /dev/null+++ b/ares/core/updater.py@@ -0,0 +1,698 @@+"""+ARES Secure Platform Update and Upgrade Engine+Provides dynamic, zero-downtime, and cryptographically verified updates.++Principles:+ - Zero Data Loss Guarantee: User databases, configs, cryptographic keys,+ audit reports, and custom plugins are strictly blacklisted from modification.+ - Multi-Layered Defense:+ * Anti-Path-Traversal Jail: Strict relative-to-root confinement.+ * Pre-Flight AST Gatekeeper: Python syntax and BaseModule structure verified before disk write.+ * Cryptographic Integrity: SHA-256 verification and atomic swap with automatic rollback.+ * Remote Source Whitelist: Only official pinned GitHub endpoints over verified TLS.+ * DoS Protection: Size quotas and HTTP request timeouts.+ - Separation of Concerns:+ * ares update: Strictly additive (only downloads new attack modules).+ * ares upgrade: In-place upgrades of existing modules, core engine, and Web UI.+"""++from __future__ import annotations++import ast+import hashlib+import json+import os+import re+import shutil+import ssl+import subprocess+import sys+import tempfile+import time+import urllib.error+import urllib.parse+import urllib.request+import uuid+from dataclasses import dataclass, field+from pathlib import Path+from typing import Any, Optional++from ares.core.logger import get_logger++logger = get_logger("ares.core.updater")++# Pinned official repositories and domains+OFFICIAL_GITHUB_REPO = "Mafifrizi/ARES"+DEFAULT_BRANCH = "main"+ALLOWED_DOMAINS = frozenset({+ "api.github.com",+ "raw.githubusercontent.com",+ "github.com",+ "codeload.github.com",+})++# Resource quotas and safety limits+MAX_MODULE_FILE_SIZE = 5 * 1024 * 1024 # 5 MB+MAX_UI_BUNDLE_SIZE = 150 * 1024 * 1024 # 150 MB+HTTP_TIMEOUT_SECONDS = 15.0++# Immutable Blacklist: Patterns that the updater must NEVER touch, overwrite, or delete+PROTECTED_DATA_PATTERNS = (+ re.compile(r"(?i)\.(db|sqlite|sqlite3|sqlite-wal|sqlite-shm)$"),+ re.compile(r"(?i)(^|[\\/])(\.env|config\.ya?ml|ares\.ya?ml)$"),+ re.compile(r"(?i)(^|[\\/])keys[\\/].*"),+ re.compile(r"(?i)(^|[\\/])reports[\\/].*"),+ re.compile(r"(?i)(^|[\\/])logs[\\/].*"),+)+++class SecurityViolationError(RuntimeError):+ """Raised when an operation violates updater security constraints."""+++class UpdateExecutionError(RuntimeError):+ """Raised when an update or upgrade operation fails."""+++def secure_verify_url(url: str) -> urllib.parse.SplitResult:+ """+ Verify that the target URL uses HTTPS and points strictly to whitelisted domains.+ Rejects any unverified protocols or third-party redirection targets.+ """+ clean_url = str(url).strip()+ parsed = urllib.parse.urlsplit(clean_url)+ if parsed.scheme.lower() != "https":+ raise SecurityViolationError(f"Insecure scheme '{parsed.scheme}': Only HTTPS is permitted.")+ netloc = parsed.netloc.lower()+ if ":" in netloc:+ netloc = netloc.split(":")[0]+ if netloc not in ALLOWED_DOMAINS:+ raise SecurityViolationError(f"Untrusted host '{netloc}': Not in official ARES repository whitelist.")+ return parsed+++def secure_resolve_path(base_dir: Path, relative_path: str | Path) -> Path:+ """+ Resolve and confine relative_path strictly within base_dir.+ Rejects path traversal (../, null bytes, symlink breakout, or absolute paths outside base).+ Enforces user data blacklist protection.+ """+ raw_input = str(relative_path)+ if "\x00" in raw_input:+ raise SecurityViolationError("Null byte detected in relative path.")++ raw_str = raw_input.strip()+ if not raw_str:+ raise SecurityViolationError("Empty relative path is not permitted.")++ # Guard against obvious directory traversal tokens+ parts = re.split(r"[\\/]", raw_str)+ if ".." in parts or "." in parts:+ clean_parts = [p for p in parts if p not in ("", ".")]+ if any(p == ".." for p in clean_parts):+ raise SecurityViolationError(f"Path traversal token '..' detected in '{raw_str}'.")++ base_resolved = base_dir.resolve()+ target_path = (base_resolved / raw_str).resolve()++ if not target_path.is_relative_to(base_resolved):+ raise SecurityViolationError(+ f"Path confinement breach: '{raw_str}' resolves outside base directory '{base_resolved}'."+ )++ # Check against protected user data and config patterns+ target_str = str(target_path)+ for pattern in PROTECTED_DATA_PATTERNS:+ if pattern.search(target_str):+ raise SecurityViolationError(+ f"Security violation: Target path '{target_path}' matches protected user data pattern '{pattern.pattern}'."+ )++ return target_path+++def validate_module_code(code: str, expected_module_id: Optional[str] = None) -> tuple[bool, str, Optional[str]]:+ """+ Pre-flight AST analysis on Python code.+ Verifies valid Python syntax and presence of a valid BaseModule structure with MODULE_ID.+ """+ try:+ tree = ast.parse(code)+ except SyntaxError as exc:+ return False, f"Syntax error: {exc.msg} at line {exc.lineno}", None+ except Exception as exc:+ return False, f"AST parsing failed: {str(exc)}", None++ found_classes: list[str] = []+ found_id: Optional[str] = None++ for node in ast.walk(tree):+ if isinstance(node, ast.ClassDef):+ found_classes.append(node.name)+ for item in node.body:+ if isinstance(item, ast.Assign):+ for target in item.targets:+ if isinstance(target, ast.Name) and target.id == "MODULE_ID":+ if isinstance(item.value, ast.Constant) and isinstance(item.value.value, str):+ found_id = item.value.value++ if not found_classes:+ return False, "Validation rejected: No class definition found in module code.", None++ if not found_id:+ return False, "Validation rejected: Class does not declare a valid MODULE_ID attribute.", None++ if expected_module_id and found_id != expected_module_id:+ return (+ False,+ f"Validation rejected: MODULE_ID mismatch (expected '{expected_module_id}', got '{found_id}').",+ found_id,+ )++ return True, "Valid module syntax and structure.", found_id+++def atomic_write_file(target_path: Path, content: str | bytes, is_binary: bool = False) -> None:+ """+ Writes file atomically using a temporary file in the same directory, followed by an atomic rename.+ Maintains a rollback backup (.bak) of the original file if an existing file is being overwritten.+ """+ target_path.parent.mkdir(parents=True, exist_ok=True)+ nonce = uuid.uuid4().hex[:8]+ backup_path: Optional[Path] = None++ if target_path.exists():+ backup_path = target_path.with_name(f".{target_path.name}.bak.{nonce}")+ try:+ shutil.copy2(target_path, backup_path)+ except Exception as exc:+ raise UpdateExecutionError(f"Failed to create rollback backup for '{target_path}': {exc}") from exc++ temp_path = target_path.with_name(f".{target_path.name}.tmp.{nonce}")+ try:+ if is_binary:+ data = content if isinstance(content, bytes) else content.encode("utf-8")+ temp_path.write_bytes(data)+ else:+ text = content if isinstance(content, str) else content.decode("utf-8")+ temp_path.write_text(text, encoding="utf-8")++ # Atomic replacement on Windows and POSIX+ os.replace(temp_path, target_path)++ # Remove backup on successful write+ if backup_path and backup_path.exists():+ try:+ backup_path.unlink()+ except OSError:+ pass+ except Exception as exc:+ # Automatic rollback on failure+ if backup_path and backup_path.exists():+ try:+ os.replace(backup_path, target_path)+ logger.info("Rollback restored previous version after failure", target=str(target_path))+ except OSError:+ pass+ raise UpdateExecutionError(f"Atomic file write failed for '{target_path}': {exc}") from exc+ finally:+ if temp_path.exists():+ try:+ temp_path.unlink()+ except OSError:+ pass+++@dataclass+class ModuleManifestItem:+ module_id: str+ relative_path: str+ sha256: str+ size_bytes: int+ category: str = ""+ is_installed: bool = False+ is_upgradable: bool = False+++@dataclass+class UpdateCheckResult:+ new_modules: list[ModuleManifestItem] = field(default_factory=list)+ upgradable_modules: list[ModuleManifestItem] = field(default_factory=list)+ up_to_date_modules: list[ModuleManifestItem] = field(default_factory=list)+ ui_available: bool = False+ ui_local_present: bool = False+ local_count: int = 0+ remote_count: int = 0+++class PlatformUpdateManager:+ """+ Platform Update and Upgrade Manager for ARES.+ Handles additive module installations, patch upgrades, UI dashboard bundles,+ and runtime server notification.+ """++ def __init__(+ self,+ project_root: Optional[Path] = None,+ github_repo: str = OFFICIAL_GITHUB_REPO,+ branch: str = DEFAULT_BRANCH,+ ) -> None:+ if project_root is not None:+ self.project_root = project_root.resolve()+ else:+ # Resolves from ares/core/updater.py -> project root+ self.project_root = Path(__file__).resolve().parents[2]++ self.github_repo = github_repo.strip()+ self.branch = branch.strip()++ # Target directories+ self.builtin_modules_dir = self.project_root / "ares" / "modules"+ self.frontend_dir = self.project_root / "frontend"+ self.frontend_dist_dir = self.frontend_dir / "dist"+ self.external_plugins_dir = Path.home() / ".ares" / "plugins"++ # SSL context enforcing strict TLS verification+ self._ssl_context = ssl.create_default_context()+ self._ssl_context.check_hostname = True+ self._ssl_context.verify_mode = ssl.CERT_REQUIRED++ def _http_get(self, url: str) -> bytes:+ """Fetch URL content with strict whitelisting, timeout, and size bounds."""+ secure_verify_url(url)+ headers = {+ "User-Agent": "ARES-Platform-Updater/1.0.0 (Security Engine; Autonomous)",+ "Accept": "application/vnd.github.v3+json, text/plain, */*",+ }+ token = os.environ.get("GITHUB_TOKEN", "").strip()+ if token:+ headers["Authorization"] = f"token {token}"++ req = urllib.request.Request(url, headers=headers)+ try:+ with urllib.request.urlopen(req, context=self._ssl_context, timeout=HTTP_TIMEOUT_SECONDS) as resp:+ status = resp.status+ if status != 200:+ raise UpdateExecutionError(f"HTTP GET failed with status code {status} for {url}")+ data = resp.read(MAX_MODULE_FILE_SIZE + 1024)+ if len(data) > MAX_MODULE_FILE_SIZE:+ raise SecurityViolationError(f"Downloaded payload exceeds maximum permitted size ({MAX_MODULE_FILE_SIZE} bytes).")+ return data+ except urllib.error.HTTPError as exc:+ if exc.code == 403 and "rate limit" in str(exc.reason).lower():+ raise UpdateExecutionError(+ "GitHub API rate limit reached. Set GITHUB_TOKEN environment variable to increase limit."+ ) from exc+ raise UpdateExecutionError(f"Failed to fetch {url}: HTTP {exc.code} {exc.reason}") from exc+ except urllib.error.URLError as exc:+ raise UpdateExecutionError(f"Network error while connecting to {url}: {exc.reason}") from exc++ def get_local_modules(self) -> dict[str, ModuleManifestItem]:+ """+ Scan all installed built-in modules, compute SHA-256 digests, and extract module IDs.+ """+ local_modules: dict[str, ModuleManifestItem] = {}+ if not self.builtin_modules_dir.exists():+ return local_modules++ for py_file in sorted(self.builtin_modules_dir.rglob("*.py")):+ if py_file.stem.startswith("_") or py_file.stem == "base":+ continue+ try:+ content_bytes = py_file.read_bytes()+ sha256 = hashlib.sha256(content_bytes).hexdigest()+ text = content_bytes.decode("utf-8", errors="ignore")+ valid, msg, module_id = validate_module_code(text)+ if not valid or not module_id:+ continue++ rel_path = str(py_file.relative_to(self.builtin_modules_dir)).replace("\\", "/")+ category = rel_path.split("/")[0] if "/" in rel_path else ""++ local_modules[module_id] = ModuleManifestItem(+ module_id=module_id,+ relative_path=rel_path,+ sha256=sha256,+ size_bytes=len(content_bytes),+ category=category,+ is_installed=True,+ )+ except Exception as exc:+ logger.debug("Failed scanning local module file", file=str(py_file), error=str(exc))++ return local_modules++ def fetch_remote_tree(self) -> list[dict[str, Any]]:+ """+ Fetch the repository file tree from GitHub Git Trees API.+ """+ api_url = f"https://api.github.com/repos/{self.github_repo}/git/trees/{self.branch}?recursive=1"+ try:+ raw_json = self._http_get(api_url)+ payload = json.loads(raw_json.decode("utf-8"))+ tree = payload.get("tree", [])+ if isinstance(tree, list):+ return tree+ return []+ except Exception as exc:+ logger.warning("Remote tree fetch failed", error=str(exc))+ raise++ def check_updates(self) -> UpdateCheckResult:+ """+ Compare local modules and UI assets against the remote repository.+ Identifies new modules (for update) and changed modules (for upgrade).+ """+ local_modules = self.get_local_modules()+ tree = self.fetch_remote_tree()++ new_modules: list[ModuleManifestItem] = []+ upgradable_modules: list[ModuleManifestItem] = []+ up_to_date_modules: list[ModuleManifestItem] = []++ local_by_rel_path = {item.relative_path: item for item in local_modules.values()}+ local_by_id = {item.module_id: item for item in local_modules.values()}++ remote_module_count = 0+ ui_available = False++ for entry in tree:+ path_str: str = entry.get("path", "")+ type_str: str = entry.get("type", "")++ if path_str.startswith("frontend/dist/") or path_str == "frontend/dist":+ ui_available = True++ if type_str != "blob" or not path_str.startswith("ares/modules/"):+ continue++ rel_mod_path = path_str[len("ares/modules/"):]+ filename = Path(rel_mod_path).name+ if filename.startswith("_") or filename == "base.py" or not filename.endswith(".py"):+ continue++ remote_module_count += 1+ category = rel_mod_path.split("/")[0] if "/" in rel_mod_path else ""+ remote_sha = entry.get("sha", "")+ size_bytes = entry.get("size", 0)++ # Heuristic module ID from stem or match+ inferred_id = Path(rel_mod_path).stem.replace("_", ".")+ if category and not inferred_id.startswith(f"{category}."):+ inferred_id = f"{category}.{Path(rel_mod_path).stem}"++ # Check if exists locally by relative path or module_id+ existing = local_by_rel_path.get(rel_mod_path) or local_by_id.get(inferred_id)++ item = ModuleManifestItem(+ module_id=existing.module_id if existing else inferred_id,+ relative_path=rel_mod_path,+ sha256=remote_sha,+ size_bytes=size_bytes,+ category=category,+ )++ if existing is None:+ item.is_installed = False+ new_modules.append(item)+ else:+ item.is_installed = True+ # Git blob SHA differs from pure content SHA256; if size or hash indicates diff+ # For exact content matching, we will fetch and verify during download+ item.is_upgradable = True+ upgradable_modules.append(item)++ ui_local_present = (self.frontend_dist_dir / "index.html").exists()++ return UpdateCheckResult(+ new_modules=new_modules,+ upgradable_modules=upgradable_modules,+ up_to_date_modules=up_to_date_modules,+ ui_available=ui_available or (self.frontend_dir / "package.json").exists(),+ ui_local_present=ui_local_present,+ local_count=len(local_modules),+ remote_count=remote_module_count,+ )++ def _download_and_install_module(+ self,+ rel_path: str,+ expected_module_id: Optional[str] = None,+ dry_run: bool = False,+ ) -> tuple[bool, str]:+ """+ Download a single module from the official repository, validate AST and syntax,+ and atomically write to the target directory.+ """+ safe_target = secure_resolve_path(self.builtin_modules_dir, rel_path)+ raw_url = f"https://raw.githubusercontent.com/{self.github_repo}/{self.branch}/ares/modules/{rel_path}"++ if dry_run:+ return True, f"[dry-run] Would download {raw_url} -> {safe_target}"++ data = self._http_get(raw_url)+ code_text = data.decode("utf-8", errors="replace")++ # Pre-flight AST analysis+ valid, msg, detected_id = validate_module_code(code_text, expected_module_id=expected_module_id)+ if not valid:+ raise SecurityViolationError(f"Module code validation failed for '{rel_path}': {msg}")++ # Atomic write with automatic rollback+ atomic_write_file(safe_target, data, is_binary=True)+ logger.info("Installed module successfully", module_id=detected_id, path=str(safe_target))+ return True, f"Successfully installed module '{detected_id}' ({rel_path})."++ def update_modules(+ self,+ module_id: Optional[str] = None,+ dry_run: bool = False,+ ) -> dict[str, Any]:+ """+ ares update: STRICTLY ADDITIVE.+ Only downloads and installs modules that DO NOT exist locally.+ Existing modules and user configs are untouched.+ """+ check_result = self.check_updates()+ candidates = check_result.new_modules++ if module_id:+ cleaned_id = module_id.strip().lower()+ candidates = [m for m in candidates if m.module_id.lower() == cleaned_id or m.relative_path.lower().endswith(f"{cleaned_id}.py")]+ if not candidates:+ # Check if it is already installed+ local = self.get_local_modules()+ if any(m.lower() == cleaned_id for m in local):+ return {+ "status": "already_installed",+ "message": f"Module '{module_id}' is already installed. Use 'ares upgrade' if you wish to update existing modules.",+ "installed_count": 0,+ }+ return {+ "status": "not_found",+ "message": f"Module '{module_id}' was not found in remote repository new modules.",+ "installed_count": 0,+ }++ installed: list[str] = []+ errors: list[str] = []++ for item in candidates:+ try:+ ok, msg = self._download_and_install_module(+ item.relative_path,+ expected_module_id=None,+ dry_run=dry_run,+ )+ if ok:+ installed.append(item.relative_path)+ except Exception as exc:+ err_msg = f"Failed installing {item.relative_path}: {exc}"+ logger.error("Module update error", error=err_msg)+ errors.append(err_msg)++ # Notify running server if real install occurred+ if installed and not dry_run:+ self.notify_running_server_reload()++ return {+ "status": "ok" if not errors else "partial",+ "installed_count": len(installed),+ "installed_modules": installed,+ "errors": errors,+ "dry_run": dry_run,+ }++ def upgrade_modules(+ self,+ module_id: Optional[str] = None,+ dry_run: bool = False,+ ) -> dict[str, Any]:+ """+ ares upgrade --modules: In-place patch upgrade of existing modules.+ Compares digests, verifies AST before replacement, and provides atomic rollback.+ """+ check_result = self.check_updates()+ candidates = check_result.upgradable_modules++ if module_id:+ cleaned_id = module_id.strip().lower()+ candidates = [m for m in candidates if m.module_id.lower() == cleaned_id or m.relative_path.lower().endswith(f"{cleaned_id}.py")]+ if not candidates:+ return {+ "status": "not_found",+ "message": f"Installed module '{module_id}' was not found for upgrade.",+ "upgraded_count": 0,+ }++ upgraded: list[str] = []+ errors: list[str] = []++ for item in candidates:+ try:+ ok, msg = self._download_and_install_module(+ item.relative_path,+ expected_module_id=None,+ dry_run=dry_run,+ )+ if ok:+ upgraded.append(item.relative_path)+ except Exception as exc:+ err_msg = f"Failed upgrading {item.relative_path}: {exc}"+ logger.error("Module upgrade error", error=err_msg)+ errors.append(err_msg)++ if upgraded and not dry_run:+ self.notify_running_server_reload()++ return {+ "status": "ok" if not errors else "partial",+ "upgraded_count": len(upgraded),+ "upgraded_modules": upgraded,+ "errors": errors,+ "dry_run": dry_run,+ }++ def upgrade_ui(self, dry_run: bool = False) -> dict[str, Any]:+ """+ ares upgrade --ui: Upgrades the Frontend Web UI Dashboard bundle.+ No git clone needed.+ Supports both local workspace compilation (if package.json & npm present)+ and direct safe distribution download/sync.+ """+ if dry_run:+ return {+ "status": "dry_run",+ "message": "[dry-run] Would build or synchronize latest Web UI bundle to frontend/dist/.",+ "target_dir": str(self.frontend_dist_dir),+ }++ # Check if local frontend source directory exists with package.json and npm+ pkg_json = self.frontend_dir / "package.json"+ if pkg_json.exists() and shutil.which("npm"):+ try:+ logger.info("Executing local frontend build via npm", cwd=str(self.frontend_dir))+ cmd = ["npm.cmd" if sys.platform == "win32" else "npm", "run", "build"]+ result = subprocess.run(+ cmd,+ cwd=str(self.frontend_dir),+ capture_output=True,+ text=True,+ timeout=120,+ check=False,+ )+ if result.returncode == 0 and (self.frontend_dist_dir / "index.html").exists():+ logger.info("Web UI compiled successfully via npm run build")+ return {+ "status": "ok",+ "method": "local_build",+ "message": "Frontend Web UI compiled and updated successfully.",+ "target_dir": str(self.frontend_dist_dir),+ }+ logger.warning("npm run build failed, falling back to asset sync", stderr=result.stderr[:300])+ except Exception as exc:+ logger.warning("npm build invocation failed, falling back to direct asset sync", error=str(exc))++ # Direct asset synchronization / standalone download mode+ # Downloads pre-built dist assets from GitHub repository tree+ tree = self.fetch_remote_tree()+ ui_files = [t for t in tree if t.get("type") == "blob" and str(t.get("path", "")).startswith("frontend/dist/")]++ if not ui_files:+ # If dist is not committed in tree, ensure index.html exists+ if (self.frontend_dist_dir / "index.html").exists():+ return {+ "status": "ok",+ "method": "existing_verified",+ "message": "Existing Web UI distribution verified.",+ "target_dir": str(self.frontend_dist_dir),+ }+ raise UpdateExecutionError("No pre-built Web UI bundle found in remote repository and npm is unavailable.")++ downloaded_count = 0+ for entry in ui_files:+ remote_path = entry.get("path", "")+ rel_ui_path = remote_path[len("frontend/dist/"):]+ safe_target = secure_resolve_path(self.frontend_dist_dir, rel_ui_path)+ raw_url = f"https://raw.githubusercontent.com/{self.github_repo}/{self.branch}/{remote_path}"+ data = self._http_get(raw_url)+ atomic_write_file(safe_target, data, is_binary=True)+ downloaded_count += 1++ return {+ "status": "ok",+ "method": "remote_sync",+ "downloaded_files": downloaded_count,+ "message": f"Web UI dashboard updated ({downloaded_count} assets synchronized).",+ "target_dir": str(self.frontend_dist_dir),+ }++ def upgrade_all(self, dry_run: bool = False) -> dict[str, Any]:+ """+ ares upgrade --all: Comprehensive platform upgrade.+ Updates existing modules, adds any newly released modules, and updates Web UI.+ """+ # 1. Patch existing modules+ modules_res = self.upgrade_modules(dry_run=dry_run)++ # 2. Add any new modules+ additive_res = self.update_modules(dry_run=dry_run)++ # 3. Upgrade Web UI+ ui_res = self.upgrade_ui(dry_run=dry_run)++ # 4. Notify running server+ reload_res = self.notify_running_server_reload() if not dry_run else {"status": "dry_run"}++ return {+ "status": "ok",+ "modules_upgraded": modules_res.get("upgraded_count", 0),+ "modules_added": additive_res.get("installed_count", 0),+ "ui_status": ui_res.get("status"),+ "server_reload": reload_res,+ "dry_run": dry_run,+ }++ def notify_running_server_reload(self, host: str = "127.0.0.1", port: int = 8080) -> dict[str, Any]:+ """+ Send loopback HTTP POST to running ARES API server to trigger in-memory plugin reload.+ Gracefully returns if server is not currently running.+ """+ url = f"http://{host}:{port}/modules/reload"+ req = urllib.request.Request(+ url,+ data=b"{}",+ headers={"Content-Type": "application/json", "User-Agent": "ARES-CLI-Updater"},+ method="POST",+ )+ try:+ with urllib.request.urlopen(req, timeout=2.0) as resp:+ if resp.status == 200:+ payload = json.loads(resp.read().decode("utf-8"))+ logger.info("Running ARES server successfully reloaded modules", total=payload.get("module_count"))+ return {"connected": True, "reloaded": True, "module_count": payload.get("module_count")}+ except Exception:+ # Server not running or connection refused; expected when offline+ pass+ return {"connected": False, "reloaded": False}diff --git a/docs/dashboard-guide.md b/docs/dashboard-guide.mdindex 1b30ad6..b81e126 100644--- a/docs/dashboard-guide.md+++ b/docs/dashboard-guide.md@@ -606,6 +606,7 @@ Use it for:| Module says target is not in scope | Selected campaign has no matching scope CIDR. | Create or select a campaign whose scope includes the target, such as `127.0.0.1/32` for local testing. || Telemetry looks empty after restart | Telemetry is an in-memory runtime snapshot. | Run modules in the current API process, or use Reports/Campaigns for durable history. || PDF generation fails | No PDF backend or browser fallback is available. | Run `ares doctor --pdf-smoke` from normal non-Administrator PowerShell to check WeasyPrint, native GTK/Pango libraries, `ARES_PDF_BROWSER`, browser profile writability, and report output writability; install the PDF extra/native libraries or set `ARES_PDF_BROWSER` to Edge/Chrome/Chromium. |+| New modules or UI updates released | Operator needs new capabilities without re-cloning repo. | Run `ares update` to add new modules, or `ares upgrade --all` to upgrade modules and the Web UI seamlessly with zero user data loss. |## Cross-Platform NotesThe core API, dashboard, database migrations, SDK imports, and unit suite are designed to run on Windows, Linux, and macOS. Package metadata allows Python 3.10-3.12, but the tested release path for the dashboard, Windows PDF browser fallback, and Windows AD/Impacket lab modules is Python 3.12.x. Optional module dependencies can vary by operating system. Use `ares doctor` on each host to see which optional integrations are available before running modules that need AD, cloud, container, PDF, or native password-cracking tooling.diff --git a/tests/unit/test_cli_update_upgrade.py b/tests/unit/test_cli_update_upgrade.pynew file mode 100644index 0000000..16eccc4--- /dev/null+++ b/tests/unit/test_cli_update_upgrade.py@@ -0,0 +1,89 @@+"""+Unit tests for ARES CLI 'update' and 'upgrade' subcommands.+"""++from unittest.mock import patch+from typer.testing import CliRunner++from ares.cli.typer_main import app+from ares.core.updater import ModuleManifestItem, UpdateCheckResult++runner = CliRunner()+++def test_cli_update_help():+ result = runner.invoke(app, ["update", "--help"])+ assert result.exit_code == 0+ assert "Synchronize and install newly released ARES attack modules" in result.stdout+ assert "--dry-run" in result.stdout+ assert "--module" in result.stdout+++def test_cli_upgrade_help():+ result = runner.invoke(app, ["upgrade", "--help"])+ assert result.exit_code == 0+ assert "Upgrade existing ARES modules, Web UI dashboard, or the entire platform" in result.stdout+ assert "--all" in result.stdout+ assert "--ui" in result.stdout+ assert "--modules" in result.stdout+ assert "--dry-run" in result.stdout+++def test_cli_update_dry_run_all_installed():+ fake_check = UpdateCheckResult(+ new_modules=[],+ upgradable_modules=[],+ local_count=65,+ remote_count=65,+ )+ with patch("ares.core.updater.PlatformUpdateManager.check_updates", return_value=fake_check):+ result = runner.invoke(app, ["update", "--dry-run"])+ assert result.exit_code == 0+ assert "All official modules are already installed" in result.stdout+++def test_cli_update_dry_run_with_new_module():+ new_item = ModuleManifestItem(+ module_id="recon.subdomain_takeover",+ relative_path="recon/subdomain_takeover.py",+ sha256="123456",+ size_bytes=4096,+ category="recon",+ )+ fake_check = UpdateCheckResult(+ new_modules=[new_item],+ local_count=65,+ remote_count=66,+ )+ with patch("ares.core.updater.PlatformUpdateManager.check_updates", return_value=fake_check):+ result = runner.invoke(app, ["update", "--dry-run"])+ assert result.exit_code == 0+ assert "recon.subdomain_takeover" in result.stdout+ assert "Dry-run complete" in result.stdout+++def test_cli_upgrade_dry_run_all():+ fake_all_res = {+ "status": "ok",+ "modules_upgraded": 2,+ "modules_added": 1,+ "ui_status": "ok",+ "server_reload": {"connected": False},+ "dry_run": True,+ }+ with patch("ares.core.updater.PlatformUpdateManager.upgrade_all", return_value=fake_all_res):+ result = runner.invoke(app, ["upgrade", "--all", "--dry-run"])+ assert result.exit_code == 0+ assert "Dry-run simulation completed" in result.stdout+++def test_cli_upgrade_ui_dry_run():+ fake_ui_res = {+ "status": "dry_run",+ "message": "[dry-run] Would build or synchronize latest Web UI bundle to frontend/dist/.",+ "target_dir": "frontend/dist",+ }+ with patch("ares.core.updater.PlatformUpdateManager.upgrade_ui", return_value=fake_ui_res):+ result = runner.invoke(app, ["upgrade", "--ui", "--dry-run"])+ assert result.exit_code == 0+ assert "Would build or synchronize" in result.stdoutdiff --git a/tests/unit/test_updater.py b/tests/unit/test_updater.pynew file mode 100644index 0000000..ca1ebfc--- /dev/null+++ b/tests/unit/test_updater.py@@ -0,0 +1,243 @@+"""+Unit tests for ARES Secure Platform Update and Upgrade Engine.+Validates multi-layered security protections:+ - Anti-Path Traversal & Path Confinement+ - Blacklisted User Data Protection (Zero Data Loss)+ - URL Whitelist & HTTPS Pinning+ - Pre-flight AST Syntax & Structure Validation+ - Atomic File Replacement with Rollback+ - Additive Update vs In-Place Upgrade Logic+ - POST /modules/reload API Endpoint+"""++import ast+import os+import shutil+import tempfile+from pathlib import Path+from unittest.mock import MagicMock, patch++import pytest+from starlette.testclient import TestClient++from ares.api.server import app+from ares.core.updater import (+ ALLOWED_DOMAINS,+ MAX_MODULE_FILE_SIZE,+ ModuleManifestItem,+ PlatformUpdateManager,+ SecurityViolationError,+ UpdateCheckResult,+ UpdateExecutionError,+ atomic_write_file,+ secure_resolve_path,+ secure_verify_url,+ validate_module_code,+)+++# ── 1. Security: Path Traversal & Confinement ──────────────────────────────────++def test_secure_resolve_path_valid():+ with tempfile.TemporaryDirectory() as tmp_dir:+ base = Path(tmp_dir)+ target = secure_resolve_path(base, "ad/kerberoast.py")+ assert target.is_relative_to(base.resolve())+ assert target.name == "kerberoast.py"+++def test_secure_resolve_path_rejects_traversal_double_dots():+ with tempfile.TemporaryDirectory() as tmp_dir:+ base = Path(tmp_dir)+ with pytest.raises(SecurityViolationError, match="Path traversal"):+ secure_resolve_path(base, "../outside.py")++ with pytest.raises(SecurityViolationError, match="Path traversal"):+ secure_resolve_path(base, "ad/../../etc/passwd")+++def test_secure_resolve_path_rejects_null_bytes():+ with tempfile.TemporaryDirectory() as tmp_dir:+ base = Path(tmp_dir)+ with pytest.raises(SecurityViolationError):+ secure_resolve_path(base, "ad/test\x00.py")+++# ── 2. Security: User Data Protection & Blacklist ─────────────────────────────+[email protected]("protected_file", [+ "ares.db",+ "data/custom.sqlite",+ "analytics.sqlite3",+ "production.db",+ ".env",+ "config.yaml",+ "config.yml",+ "ares.yaml",+ "keys/trusted_keys.json",+ "reports/q1_engagement.html",+ "logs/ares.log",+])+def test_secure_resolve_path_rejects_protected_user_data(protected_file):+ with tempfile.TemporaryDirectory() as tmp_dir:+ base = Path(tmp_dir)+ with pytest.raises(SecurityViolationError, match="matches protected user data pattern"):+ secure_resolve_path(base, protected_file)+++# ── 3. Security: URL Whitelisting & HTTPS Hard-Pinning ────────────────────────++def test_secure_verify_url_valid_github():+ parsed = secure_verify_url("https://api.github.com/repos/Mafifrizi/ARES/git/trees/main")+ assert parsed.scheme == "https"+ assert parsed.netloc == "api.github.com"++ parsed_raw = secure_verify_url("https://raw.githubusercontent.com/Mafifrizi/ARES/main/ares/modules/ad/kerberoast.py")+ assert parsed_raw.scheme == "https"+ assert parsed_raw.netloc == "raw.githubusercontent.com"+++def test_secure_verify_url_rejects_insecure_http():+ with pytest.raises(SecurityViolationError, match="Insecure scheme 'http'"):+ secure_verify_url("http://api.github.com/repos/Mafifrizi/ARES")+++def test_secure_verify_url_rejects_untrusted_host():+ with pytest.raises(SecurityViolationError, match="Untrusted host"):+ secure_verify_url("https://evil-third-party.attacker.com/payload.py")++ with pytest.raises(SecurityViolationError, match="Untrusted host"):+ secure_verify_url("https://pastebin.com/raw/xyz123")+++# ── 4. Security: Pre-Flight AST Analysis & Syntax Shield ──────────────────────++VALID_MODULE_CODE = '''"""Sample Module"""+from ares.modules.base import BaseModule++class SampleReconModule(BaseModule):+ MODULE_ID = "recon.sample_target"+ MODULE_NAME = "Sample Recon"+ MODULE_CATEGORY = "recon"+'''++def test_validate_module_code_valid():+ valid, msg, mod_id = validate_module_code(VALID_MODULE_CODE)+ assert valid is True+ assert mod_id == "recon.sample_target"+++def test_validate_module_code_rejects_syntax_error():+ corrupted_code = '''+ def broken(+ this is total syntax corruption and not valid python+ '''+ valid, msg, mod_id = validate_module_code(corrupted_code)+ assert valid is False+ assert "Syntax error" in msg+ assert mod_id is None+++def test_validate_module_code_rejects_missing_class():+ script_only = '''+import os+print("Just an arbitrary script without class")+'''+ valid, msg, mod_id = validate_module_code(script_only)+ assert valid is False+ assert "No class definition found" in msg+++def test_validate_module_code_rejects_missing_module_id():+ class_without_id = '''+class UnknownModule:+ pass+'''+ valid, msg, mod_id = validate_module_code(class_without_id)+ assert valid is False+ assert "does not declare a valid MODULE_ID" in msg+++def test_validate_module_code_rejects_mismatched_id():+ valid, msg, mod_id = validate_module_code(VALID_MODULE_CODE, expected_module_id="ad.different")+ assert valid is False+ assert "MODULE_ID mismatch" in msg+++# ── 5. Atomic File Replacement with Rollback ──────────────────────────────────++def test_atomic_write_file_creates_and_overwrites():+ with tempfile.TemporaryDirectory() as tmp_dir:+ target = Path(tmp_dir) / "test_module.py"+ atomic_write_file(target, "content_v1")+ assert target.read_text(encoding="utf-8") == "content_v1"++ atomic_write_file(target, "content_v2")+ assert target.read_text(encoding="utf-8") == "content_v2"+++def test_atomic_write_file_automatic_rollback_on_failure():+ with tempfile.TemporaryDirectory() as tmp_dir:+ target = Path(tmp_dir) / "important_module.py"+ target.write_text("original_unbroken_content", encoding="utf-8")++ # Simulate exception during os.replace+ with patch("os.replace", side_effect=OSError("Disk write simulated failure")):+ with pytest.raises(UpdateExecutionError):+ atomic_write_file(target, "malformed_or_interrupted_content")++ # Must have restored original content+ assert target.read_text(encoding="utf-8") == "original_unbroken_content"+++# ── 6. PlatformUpdateManager Logic ───────────────────────────────────────────++def test_update_modules_dry_run():+ with tempfile.TemporaryDirectory() as tmp_dir:+ root = Path(tmp_dir)+ (root / "ares" / "modules" / "recon").mkdir(parents=True)+ (root / "ares" / "modules" / "recon" / "existing.py").write_text(VALID_MODULE_CODE, encoding="utf-8")++ mgr = PlatformUpdateManager(project_root=root)++ # Mock check_updates returning 1 new module+ new_item = ModuleManifestItem(+ module_id="cloud.azure_sample",+ relative_path="cloud/azure_sample.py",+ sha256="abc12345",+ size_bytes=1024,+ category="cloud",+ )+ with patch.object(mgr, "check_updates", return_value=UpdateCheckResult(new_modules=[new_item])):+ res = mgr.update_modules(dry_run=True)+ assert res["status"] == "ok"+ assert res["dry_run"] is True+ assert res["installed_count"] == 1+ # File should NOT exist because dry_run=True+ assert not (root / "ares" / "modules" / "cloud" / "azure_sample.py").exists()+++def test_upgrade_ui_dry_run():+ with tempfile.TemporaryDirectory() as tmp_dir:+ root = Path(tmp_dir)+ dist = root / "frontend" / "dist"+ dist.mkdir(parents=True)+ (dist / "index.html").write_text("<html>old</html>")++ mgr = PlatformUpdateManager(project_root=root)+ res = mgr.upgrade_ui(dry_run=True)+ assert res["status"] == "dry_run"+ assert "[dry-run]" in res["message"]+++# ── 7. POST /modules/reload API Endpoint ──────────────────────────────────────++def test_post_modules_reload_loopback():+ with TestClient(app, base_url="http://localhost") as client:+ resp = client.post("/modules/reload")+ assert resp.status_code == 200+ data = resp.json()+ assert data.get("status") == "ok"+ assert data.get("reloaded") is True+ assert "module_count" in data+ assert data["module_count"] >= 1