Merge pull request #40 from FuzzingLabs/fuzzforge-ai-new-version

Missing modifications for the new version

Author: AFredefon

README.md

@@ -287,5 +287,6 @@ BSL 1.1 - See [LICENSE](LICENSE) for details.
 ---
 
 <p align="center">
-  <strong>Built with ❤️ by <a href="https://fuzzinglabs.com">FuzzingLabs</a></strong>
+  <strong>Maintained by <a href="https://fuzzinglabs.com">FuzzingLabs</a></strong>
+  <br>
 </p>

fuzzforge-common/src/fuzzforge_common/sandboxes/engines/docker/cli.py

@@ -420,7 +420,7 @@ def list_containers(self, all_containers: bool = True) -> list[dict]:
     def read_file_from_image(self, image: str, path: str) -> str:
         """Read a file from inside an image without starting a long-running container.
 
-        Creates a temporary container, reads the file via cat, and removes it.
+        Uses docker run with --entrypoint override to read the file via cat.
 
         :param image: Image reference (e.g., "fuzzforge-rust-analyzer:latest").
         :param path: Path to file inside image.
@@ -429,30 +429,14 @@ def read_file_from_image(self, image: str, path: str) -> str:
         """
         logger = get_logger()
 
-        # Create a temporary container (don't start it)
-        create_result = self._run(
-            ["create", "--rm", image, "cat", path],
+        # Use docker run with --entrypoint to override any container entrypoint
+        result = self._run(
+            ["run", "--rm", "--entrypoint", "cat", image, path],
             check=False,
         )
 
-        if create_result.returncode != 0:
-            logger.debug("failed to create container for file read", image=image, path=path)
+        if result.returncode != 0:
+            logger.debug("failed to read file from image", image=image, path=path, stderr=result.stderr)
             return ""
 
-        container_id = create_result.stdout.strip()
-        
-        try:
-            # Start the container and capture output (cat will run and exit)
-            start_result = self._run(
-                ["start", "-a", container_id],
-                check=False,
-            )
-            
-            if start_result.returncode != 0:
-                logger.debug("failed to read file from image", image=image, path=path)
-                return ""
-            
-            return start_result.stdout
-        finally:
-            # Cleanup: remove the container (may already be removed due to --rm)
-            self._run(["rm", "-f", container_id], check=False)
+        return result.stdout

fuzzforge-common/src/fuzzforge_common/sandboxes/engines/podman/cli.py

@@ -481,7 +481,7 @@ def list_containers(self, all_containers: bool = True) -> list[dict]:
     def read_file_from_image(self, image: str, path: str) -> str:
         """Read a file from inside an image without starting a long-running container.
 
-        Creates a temporary container, reads the file via cat, and removes it.
+        Uses podman run with --entrypoint override to read the file via cat.
 
         :param image: Image reference (e.g., "fuzzforge-rust-analyzer:latest").
         :param path: Path to file inside image.
@@ -490,33 +490,17 @@ def read_file_from_image(self, image: str, path: str) -> str:
         """
         logger = get_logger()
 
-        # Create a temporary container (don't start it)
-        create_result = self._run(
-            ["create", "--rm", image, "cat", path],
+        # Use podman run with --entrypoint to override any container entrypoint
+        result = self._run(
+            ["run", "--rm", "--entrypoint", "cat", image, path],
             check=False,
         )
 
-        if create_result.returncode != 0:
-            logger.debug("failed to create container for file read", image=image, path=path)
+        if result.returncode != 0:
+            logger.debug("failed to read file from image", image=image, path=path, stderr=result.stderr)
             return ""
 
-        container_id = create_result.stdout.strip()
-        
-        try:
-            # Start the container and capture output (cat will run and exit)
-            start_result = self._run(
-                ["start", "-a", container_id],
-                check=False,
-            )
-            
-            if start_result.returncode != 0:
-                logger.debug("failed to read file from image", image=image, path=path)
-                return ""
-            
-            return start_result.stdout
-        finally:
-            # Cleanup: remove the container (may already be removed due to --rm)
-            self._run(["rm", "-f", container_id], check=False)
+        return result.stdout
 
     # -------------------------------------------------------------------------
     # Utility Methods

fuzzforge-mcp/src/fuzzforge_mcp/application.py

@@ -46,10 +46,10 @@ async def lifespan(_: FastMCP) -> AsyncGenerator[Settings]:
 
 Typical workflow:
 1. Initialize a project with `init_project`
-2. Set project assets with `set_project_assets` (optional)
+2. Set project assets with `set_project_assets` (optional, only needed once for the source directory)
 3. List available modules with `list_modules`
-4. Execute a module with `execute_module`
-5. Get results with `get_execution_results`
+4. Execute a module with `execute_module` — use `assets_path` param to pass different inputs per module
+5. Read outputs from `results_path` returned by `execute_module` — check module's `output_artifacts` metadata for filenames
 """,
     lifespan=lifespan,
 )

fuzzforge-mcp/src/fuzzforge_mcp/tools/modules.py

@@ -92,9 +92,14 @@ async def execute_module(
     This tool runs a module in a sandboxed environment.
     The module receives input assets and produces output results.
 
+    The response includes `results_path` pointing to the stored results archive.
+    Use this path directly to read outputs — no need to call `get_execution_results`.
+
     :param module_identifier: The identifier of the module to execute.
     :param configuration: Optional configuration dict to pass to the module.
-    :param assets_path: Optional path to input assets. If not provided, uses project assets.
+    :param assets_path: Optional path to input assets. Use this to pass specific
+        inputs to a module (e.g. crash files to crash-analyzer) without changing
+        the project's default assets. If not provided, uses project assets.
     :return: Execution result including status and results path.
 
     """

fuzzforge-mcp/src/fuzzforge_mcp/tools/projects.py

@@ -56,12 +56,17 @@ async def init_project(project_path: str | None = None) -> dict[str, Any]:
 
 @mcp.tool
 async def set_project_assets(assets_path: str) -> dict[str, Any]:
-    """Set the initial assets for a project.
+    """Set the initial assets (source code) for a project.
 
-    Assets are input files that will be provided to modules during execution.
-    This could be source code, contracts, binaries, etc.
+    This sets the DEFAULT source directory mounted into modules.
+    Usually this is the project root containing source code (e.g. Cargo.toml, src/).
 
-    :param assets_path: Path to assets file (archive) or directory.
+    IMPORTANT: This OVERWRITES the previous assets path. Only call this once
+    during project setup. To pass different inputs to a specific module
+    (e.g. crash files to crash-analyzer), use the `assets_path` parameter
+    on `execute_module` instead.
+
+    :param assets_path: Path to the project source directory or archive.
     :return: Result including stored assets path.
 
     """

fuzzforge-modules/cargo-fuzzer/pyproject.toml

@@ -33,16 +33,11 @@ package = true
 # FuzzForge module metadata for AI agent discovery
 [tool.fuzzforge.module]
 identifier = "fuzzforge-cargo-fuzzer"
-category = "fuzzer"
-language = "rust"
-pipeline_stage = "fuzzing"
-pipeline_order = 3
 suggested_predecessors = ["fuzzforge-harness-tester"]
 continuous_mode = true
-typical_duration = "continuous"
 
 use_cases = [
-    "Run continuous coverage-guided fuzzing with libFuzzer",
+    "Run continuous coverage-guided fuzzing on Rust targets with libFuzzer",
     "Execute cargo-fuzz on validated harnesses",
     "Produce crash artifacts for analysis",
     "Long-running fuzzing campaign"
@@ -55,10 +50,9 @@ common_inputs = [
 ]
 
 output_artifacts = [
+    "fuzzing_results.json",
     "crashes/",
-    "coverage-data/",
-    "corpus/",
-    "fuzzing-stats.json"
+    "results.json"
 ]
 
-output_treatment = "Show fuzzing-stats.json as a live summary with total_executions, exec/sec, coverage_percent, and crashes_found. List files in crashes/ directory if any crashes found. The corpus/ and coverage-data/ directories are artifacts for downstream modules, don't display their contents."
+output_treatment = "Read fuzzing_results.json which contains: targets_fuzzed, total_crashes, total_executions, crashes_path, and results array with per-target crash info. Display summary of crashes found. The crashes/ directory contains crash inputs for downstream crash-analyzer."

fuzzforge-modules/cargo-fuzzer/src/module/mod.py

@@ -458,34 +458,56 @@ def _collect_crashes(self, target: str) -> list[CrashInfo]:
 
         """
         crashes: list[CrashInfo] = []
+        seen_hashes: set[str] = set()
 
         if self._fuzz_project_path is None or self._crashes_path is None:
             return crashes
 
-        # Check for crashes in the artifacts directory
-        artifacts_dir = self._fuzz_project_path / "artifacts" / target
-
-        if artifacts_dir.is_dir():
-            for crash_file in artifacts_dir.glob("crash-*"):
-                if crash_file.is_file():
-                    # Copy crash to output
-                    output_crash = self._crashes_path / target
-                    output_crash.mkdir(parents=True, exist_ok=True)
-                    dest = output_crash / crash_file.name
-                    shutil.copy2(crash_file, dest)
-
-                    # Read crash input
-                    crash_data = crash_file.read_bytes()
+        # Check multiple possible crash locations:
+        # 1. Standard artifacts directory (target-specific)
+        # 2. Generic artifacts directory
+        # 3. Fuzz project root (fork mode sometimes writes here)
+        # 4. Project root (parent of fuzz directory)
+        search_paths = [
+            self._fuzz_project_path / "artifacts" / target,
+            self._fuzz_project_path / "artifacts",
+            self._fuzz_project_path,
+            self._fuzz_project_path.parent,
+        ]
 
-                    crash_info = CrashInfo(
-                        file_path=str(dest),
-                        input_hash=crash_file.name,
-                        input_size=len(crash_data),
-                    )
-                    crashes.append(crash_info)
+        for search_dir in search_paths:
+            if not search_dir.is_dir():
+                continue
+                
+            # Use rglob to recursively find crash files
+            for crash_file in search_dir.rglob("crash-*"):
+                if not crash_file.is_file():
+                    continue
+                    
+                # Skip duplicates by hash
+                if crash_file.name in seen_hashes:
+                    continue
+                seen_hashes.add(crash_file.name)
+
+                # Copy crash to output
+                output_crash = self._crashes_path / target
+                output_crash.mkdir(parents=True, exist_ok=True)
+                dest = output_crash / crash_file.name
+                shutil.copy2(crash_file, dest)
+
+                # Read crash input
+                crash_data = crash_file.read_bytes()
+
+                crash_info = CrashInfo(
+                    file_path=str(dest),
+                    input_hash=crash_file.name,
+                    input_size=len(crash_data),
+                )
+                crashes.append(crash_info)
 
-                    logger.info("found crash", target=target, file=crash_file.name)
+                logger.info("found crash", target=target, file=crash_file.name, source=str(search_dir))
 
+        logger.info("crash collection complete", target=target, total_crashes=len(crashes))
         return crashes
 
     def _write_output(self) -> None:

fuzzforge-modules/crash-analyzer/pyproject.toml

@@ -34,16 +34,11 @@ package = true
 # FuzzForge module metadata for AI agent discovery
 [tool.fuzzforge.module]
 identifier = "fuzzforge-crash-analyzer"
-category = "reporter"
-language = "rust"
-pipeline_stage = "crash-analysis"
-pipeline_order = 4
 suggested_predecessors = ["fuzzforge-cargo-fuzzer"]
 continuous_mode = false
-typical_duration = "1m"
 
 use_cases = [
-    "Analyze crash artifacts from fuzzing",
+    "Analyze Rust crash artifacts from fuzzing",
     "Deduplicate crashes by stack trace signature",
     "Triage crashes by severity (critical, high, medium, low)",
     "Generate security vulnerability reports"
@@ -56,9 +51,8 @@ common_inputs = [
 ]
 
 output_artifacts = [
-    "unique-crashes.json",
-    "crash-report.md",
-    "severity-analysis.json"
+    "crash_analysis.json",
+    "results.json"
 ]
 
-output_treatment = "Display crash-report.md as rendered markdown - this is the primary output. Show unique-crashes.json as a table with crash ID, severity, and affected function. Summarize severity-analysis.json showing counts by severity level (critical, high, medium, low)."
+output_treatment = "Read crash_analysis.json which contains: total_crashes, unique_crashes, duplicate_crashes, severity_summary (high/medium/low/unknown counts), and unique_analyses array with details per crash. Display a summary table of unique crashes by severity."

fuzzforge-modules/fuzzforge-module-template/pyproject.toml

@@ -31,40 +31,25 @@ fuzzforge-modules-sdk = { workspace = true }
 package = true
 
 # FuzzForge module metadata for AI agent discovery
-# See MODULE_METADATA.md for full documentation
 [tool.fuzzforge.module]
 # REQUIRED: Unique module identifier (should match Docker image name)
 identifier = "fuzzforge-module-template"
 
-# REQUIRED: Module category - one of: analyzer, validator, fuzzer, reporter
-category = "analyzer"
-
-# Optional: Target programming language
-language = "rust"
-
-# Optional: Pipeline stage name
-pipeline_stage = "analysis"
-
-# Optional: Numeric order in pipeline (for sorting)
-pipeline_order = 1
-
-# Optional: List of module identifiers that must run before this one
-dependencies = []
+# Optional: List of module identifiers that should run before this one
+suggested_predecessors = []
 
 # Optional: Whether this module supports continuous/background execution
 continuous_mode = false
 
-# Optional: Expected runtime (e.g., "30s", "5m", "continuous")
-typical_duration = "30s"
-
 # REQUIRED: Use cases help AI agents understand when to use this module
+# Include language/target info here (e.g., "Analyze Rust crate...")
 use_cases = [
     "FIXME: Describe what this module does",
     "FIXME: Describe typical usage scenario"
 ]
 
 # REQUIRED: What inputs the module expects
-input_requirements = [
+common_inputs = [
     "FIXME: List required input files or artifacts"
 ]