Initial commit

setup.py

@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025 FuzzingLabs
+#
+# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file
+# at the root of this repository for details.
+#
+# After the Change Date (four years from publication), this version of the
+# Licensed Work will be made available under the Apache License, Version 2.0.
+# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0
+#
+# Additional attribution and requirements are provided in the NOTICE file.
+
+"""
+FuzzForge Setup Script - One-command setup for development
+
+This script automates the entire FuzzForge development setup process,
+from checking prerequisites to running your first security scan.
+"""
+
+import os
+import sys
+import subprocess
+import platform
+import time
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+
+class Colors:
+    """ANSI color codes for terminal output"""
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    RED = '\033[91m'
+    BLUE = '\033[94m'
+    CYAN = '\033[96m'
+    WHITE = '\033[97m'
+    BOLD = '\033[1m'
+    END = '\033[0m'
+
+
+class FuzzForgeSetup:
+    """Automated FuzzForge development environment setup"""
+
+    def __init__(self):
+        self.system = platform.system().lower()
+        self.project_root = Path(__file__).parent
+        self.errors: List[str] = []
+        self.warnings: List[str] = []
+
+    def print_header(self):
+        """Print welcome header"""
+        print(f"""{Colors.CYAN}{Colors.BOLD}
+╔══════════════════════════════════════════╗
+║           FuzzForge Setup Script         ║
+║      Automated Development Setup         ║
+╚══════════════════════════════════════════╝
+{Colors.END}""")
+        print(f"{Colors.WHITE}Welcome to FuzzForge! This script will set up your development environment.{Colors.END}\n")
+
+    def run_command(self, command: str, description: str, critical: bool = True) -> Tuple[bool, str]:
+        """Run a shell command and return success status and output"""
+        print(f"{Colors.YELLOW}🔄 {description}...{Colors.END}")
+
+        try:
+            result = subprocess.run(
+                command.split(),
+                capture_output=True,
+                text=True,
+                timeout=120  # 2 minute timeout
+            )
+
+            if result.returncode == 0:
+                print(f"{Colors.GREEN}✅ {description} completed successfully{Colors.END}")
+                return True, result.stdout
+            else:
+                error_msg = f"{description} failed: {result.stderr.strip()}"
+                if critical:
+                    self.errors.append(error_msg)
+                    print(f"{Colors.RED}❌ {error_msg}{Colors.END}")
+                else:
+                    self.warnings.append(error_msg)
+                    print(f"{Colors.YELLOW}⚠️  {error_msg}{Colors.END}")
+                return False, result.stderr
+
+        except subprocess.TimeoutExpired:
+            error_msg = f"{description} timed out"
+            if critical:
+                self.errors.append(error_msg)
+            else:
+                self.warnings.append(error_msg)
+            print(f"{Colors.RED}⏰ {error_msg}{Colors.END}")
+            return False, "Timeout"
+
+        except Exception as e:
+            error_msg = f"{description} failed with exception: {e}"
+            if critical:
+                self.errors.append(error_msg)
+            else:
+                self.warnings.append(error_msg)
+            print(f"{Colors.RED}💥 {error_msg}{Colors.END}")
+            return False, str(e)
+
+    def check_prerequisites(self) -> bool:
+        """Check if required tools are installed"""
+        print(f"{Colors.BOLD}📋 Step 1: Checking Prerequisites{Colors.END}\n")
+
+        all_good = True
+
+        # Check Python version
+        python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+        if sys.version_info >= (3, 11):
+            print(f"{Colors.GREEN}✅ Python {python_version} (required: 3.11+){Colors.END}")
+        else:
+            print(f"{Colors.RED}❌ Python {python_version} (required: 3.11+){Colors.END}")
+            self.errors.append(f"Python version {python_version} is too old. Please install Python 3.11+")
+            all_good = False
+
+        # Check Docker
+        docker_success, docker_output = self.run_command("docker --version", "Checking Docker", critical=False)
+        if not docker_success:
+            self.errors.append("Docker is not installed. Please install Docker Desktop")
+            all_good = False
+
+        # Check Docker Compose
+        compose_success, _ = self.run_command("docker compose version", "Checking Docker Compose", critical=False)
+        if not compose_success:
+            self.errors.append("Docker Compose is not available. Please ensure Docker Desktop is installed properly")
+            all_good = False
+
+        # Check UV
+        uv_success, _ = self.run_command("uv --version", "Checking UV package manager", critical=False)
+        if not uv_success:
+            print(f"{Colors.YELLOW}📦 UV not found, installing UV...{Colors.END}")
+            if self.system == "darwin":  # macOS
+                subprocess.run(["curl", "-LsSf", "https://astral.sh/uv/install.sh", "|", "sh"], shell=True)
+            else:
+                subprocess.run(["pip", "install", "uv"])
+
+            # Recheck UV
+            uv_success, _ = self.run_command("uv --version", "Re-checking UV installation", critical=False)
+            if not uv_success:
+                self.warnings.append("UV installation failed. You can install it manually later")
+
+        return all_good
+
+    def setup_docker_environment(self) -> bool:
+        """Set up Docker environment"""
+        print(f"\n{Colors.BOLD}🐳 Step 2: Setting Up Docker Environment{Colors.END}\n")
+
+        # Check if Docker daemon is running
+        docker_running, _ = self.run_command("docker ps", "Checking Docker daemon", critical=False)
+        if not docker_running:
+            print(f"{Colors.YELLOW}⚠️  Docker daemon is not running. Please start Docker Desktop and try again.{Colors.END}")
+            return False
+
+        # Start FuzzForge services
+        os.chdir(self.project_root)
+
+        # Warning about first launch
+        print(f"{Colors.CYAN}ℹ️  First launch will take longer due to Docker image building (5-10 minutes).{Colors.END}")
+        print(f"{Colors.CYAN}   Subsequent starts will be much faster!{Colors.END}\n")
+
+        # Build and start services
+        print(f"{Colors.YELLOW}🔨 Building and starting FuzzForge services (this may take a while)...{Colors.END}")
+
+        # Use longer timeout for Docker build (10 minutes)
+        try:
+            result = subprocess.run(
+                ["docker", "compose", "up", "-d"],
+                capture_output=True,
+                text=True,
+                timeout=600,  # 10 minute timeout for Docker build
+                cwd=self.project_root
+            )
+
+            if result.returncode == 0:
+                print(f"{Colors.GREEN}✅ Docker services started successfully{Colors.END}")
+            else:
+                self.errors.append(f"Docker services failed to start: {result.stderr.strip()}")
+                print(f"{Colors.RED}❌ Docker services failed to start: {result.stderr.strip()}{Colors.END}")
+                return False
+
+        except subprocess.TimeoutExpired:
+            self.errors.append("Docker build timed out after 10 minutes")
+            print(f"{Colors.RED}⏰ Docker build timed out after 10 minutes{Colors.END}")
+            return False
+        except Exception as e:
+            self.errors.append(f"Docker setup failed: {e}")
+            print(f"{Colors.RED}💥 Docker setup failed: {e}{Colors.END}")
+            return False
+
+        # Wait for services to be ready with extended timeout
+        print(f"{Colors.YELLOW}⏳ Waiting for services to be ready...{Colors.END}")
+        for i in range(120):  # Wait up to 2 minutes for services to be ready
+            time.sleep(1)
+            health_success, _ = self.run_command("curl -s http://localhost:8000/health", "Health check", critical=False)
+            if health_success:
+                print(f"\n{Colors.GREEN}✅ FuzzForge API is ready at http://localhost:8000!{Colors.END}")
+                return True
+            if i % 10 == 0:  # Print progress every 10 seconds
+                print(f"\n{Colors.CYAN}   Still starting... ({i+1}s){Colors.END}")
+            else:
+                print(".", end="", flush=True)
+
+        print(f"\n{Colors.YELLOW}⚠️  Services may still be starting. Check status with 'docker compose logs'{Colors.END}")
+        print(f"{Colors.CYAN}💡 You can monitor progress with: docker compose logs -f{Colors.END}")
+        return True
+
+    def install_cli(self) -> bool:
+        """Install FuzzForge CLI"""
+        print(f"\n{Colors.BOLD}💻 Step 3: Installing FuzzForge CLI (Final Step){Colors.END}\n")
+
+        cli_dir = self.project_root / "cli"
+        if not cli_dir.exists():
+            self.errors.append("CLI directory not found")
+            return False
+
+        os.chdir(cli_dir)
+
+        # Install CLI using UV
+        success, _ = self.run_command("uv tool install .", "Installing FuzzForge CLI")
+        if not success:
+            # Fallback to pip
+            print(f"{Colors.YELLOW}📦 Trying pip installation as fallback...{Colors.END}")
+            success, _ = self.run_command("pip install .", "Installing CLI with pip")
+
+        return success
+
+
+
+    def print_next_steps(self):
+        """Print next steps for the user"""
+        print(f"\n{Colors.BOLD}{Colors.GREEN}🎉 Setup Complete!{Colors.END}")
+
+        if not self.errors:
+            print(f"""
+{Colors.CYAN}🚀 FuzzForge is now ready! Here's what you can do next:{Colors.END}
+
+{Colors.BOLD}📖 Learn More:{Colors.END}
+  • {Colors.BLUE}docs/QUICKSTART.md{Colors.END} - 5-minute module creation tutorial
+  • {Colors.BLUE}docs/PATTERNS.md{Colors.END} - Common patterns and recipes
+  • {Colors.BLUE}cli/README.md{Colors.END} - Complete CLI documentation
+
+{Colors.BOLD}🔍 Try Some Commands:{Colors.END}
+  • {Colors.WHITE}cd test_projects/vulnerable_app{Colors.END} - Navigate to test project
+  • {Colors.WHITE}fuzzforge init{Colors.END} - Initialize a FuzzForge project
+  • {Colors.WHITE}ff workflow security_assessment .{Colors.END} - Run security assessment
+  • {Colors.WHITE}ff workflow secret_detection_scan .{Colors.END} - Run secret detection
+  • {Colors.WHITE}fuzzforge status{Colors.END} - Check project and workflow status
+  • {Colors.WHITE}fuzzforge --help{Colors.END} - See all available commands
+
+{Colors.BOLD}🔧 Available Workflows:{Colors.END}
+  • {Colors.CYAN}security_assessment{Colors.END} - Comprehensive security scanning
+  • {Colors.CYAN}secret_detection_scan{Colors.END} - Credential and secret detection
+
+{Colors.BOLD}🌐 Web Interface:{Colors.END}
+  • API: {Colors.WHITE}http://localhost:8000{Colors.END}
+  • Health: {Colors.WHITE}http://localhost:8000/health{Colors.END}
+  • API Docs: {Colors.WHITE}http://localhost:8000/docs{Colors.END}
+""")
+
+        if self.warnings:
+            print(f"\n{Colors.YELLOW}⚠️  Warnings:{Colors.END}")
+            for warning in self.warnings:
+                print(f"  • {warning}")
+
+        if self.errors:
+            print(f"\n{Colors.RED}❌ Errors that need attention:{Colors.END}")
+            for error in self.errors:
+                print(f"  • {error}")
+            print(f"\n{Colors.YELLOW}🔧 Please fix these issues and run the setup again.{Colors.END}")
+
+    def run(self):
+        """Run the complete setup process"""
+        self.print_header()
+
+        # Step 1: Prerequisites
+        if not self.check_prerequisites():
+            if self.errors:
+                self.print_next_steps()
+                return False
+
+        # Step 2: Docker setup
+        if not self.setup_docker_environment():
+            if self.errors:
+                self.print_next_steps()
+                return False
+
+        # Step 3: CLI installation
+        self.install_cli()
+
+        # Final summary
+        self.print_next_steps()
+
+        return len(self.errors) == 0
+
+
+def main():
+    """Main entry point"""
+    setup = FuzzForgeSetup()
+
+    try:
+        success = setup.run()
+        sys.exit(0 if success else 1)
+    except KeyboardInterrupt:
+        print(f"\n{Colors.YELLOW}Setup interrupted by user. You can run this script again anytime.{Colors.END}")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\n{Colors.RED}Unexpected error: {e}{Colors.END}")
+        print(f"{Colors.YELLOW}Please report this issue with the error details above.{Colors.END}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()