revert

# Description of Changes

This PR introduces multi-file support for asynchronous jobs in the
Stirling PDF backend, enabling jobs to return and manage multiple result
files. Previously, job results were limited to a single file represented
by fileId, originalFileName, and contentType. This change replaces that
legacy structure with a new ResultFile abstraction and expands the
functionality throughout the core system.

ZIP File Support
If a job result is a ZIP file:
It is automatically unpacked using buffered streaming.
Each contained file is stored individually and recorded as a ResultFile.
The original ZIP is deleted after successful extraction.
If ZIP extraction fails, the job result is treated as a single file.


New and Updated API Endpoints

1. GET /api/v1/general/job/{jobId}/result

If the job has multiple files → returns a JSON metadata list.

If the job has a single file → streams the file directly.

Includes UTF-8-safe Content-Disposition headers for filename support.

2. GET /api/v1/general/job/{jobId}/result/files
New endpoint that returns:

```json
{
  "jobId": "123",
  "fileCount": 2,
  "files": [
    {
      "fileId": "abc",
      "fileName": "page1.pdf",
      "contentType": "application/pdf",
      "fileSize": 12345
    },
    ...
  ]
}
```


3. GET /api/v1/general/files/{fileId}/metadata
Returns metadata for a specific file:


4. GET /api/v1/general/files/{fileId}
Downloads a file by fileId, using metadata to determine filename and
content type.

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: pixeebot[bot] <104101892+pixeebot[bot]@users.noreply.github.com>

common/src/main/java/stirling/software/common/aop/AutoJobAspect.java

@@ -43,6 +43,7 @@ public class AutoJobAspect {
         // This aspect will run before any audit aspects due to @Order(0)
         // Extract parameters from the request and annotation
         boolean async = Boolean.parseBoolean(request.getParameter("async"));
+        log.debug("AutoJobAspect: Processing {} {} with async={}", request.getMethod(), request.getRequestURI(), async);
         long timeout = autoJobPostMapping.timeout();
         int retryCount = autoJobPostMapping.retryCount();
         boolean trackProgress = autoJobPostMapping.trackProgress();
@@ -54,19 +55,8 @@ public class AutoJobAspect {
                 retryCount,
                 trackProgress);
 
-        // Copy and process arguments
-        // In a test environment, we might need to update the original objects for verification
-        boolean isTestEnvironment = false;
-        try {
-            isTestEnvironment = Class.forName("org.junit.jupiter.api.Test") != null;
-        } catch (ClassNotFoundException e) {
-            // Not in a test environment
-        }
-
-        Object[] args =
-                isTestEnvironment
-                        ? processArgsInPlace(joinPoint.getArgs(), async)
-                        : copyAndProcessArgs(joinPoint.getArgs(), async);
+        // Process arguments in-place to avoid type mismatch issues
+        Object[] args = processArgsInPlace(joinPoint.getArgs(), async);
 
         // Extract queueable and resourceWeight parameters and validate
         boolean queueable = autoJobPostMapping.queueable();
@@ -229,79 +219,10 @@ public class AutoJobAspect {
                 resourceWeight);
     }
 
-    /**
-     * Creates deep copies of arguments when needed to avoid mutating the original objects
-     * Particularly important for PDFFile objects that might be reused by Spring
-     *
-     * @param originalArgs The original arguments
-     * @param async Whether this is an async operation
-     * @return A new array with safely processed arguments
-     */
-    private Object[] copyAndProcessArgs(Object[] originalArgs, boolean async) {
-        if (originalArgs == null || originalArgs.length == 0) {
-            return originalArgs;
-        }
-
-        Object[] processedArgs = new Object[originalArgs.length];
-
-        // Copy all arguments
-        for (int i = 0; i < originalArgs.length; i++) {
-            Object arg = originalArgs[i];
-
-            if (arg instanceof PDFFile pdfFile) {
-                // Create a copy of PDFFile to avoid mutating the original
-                // Using direct property access instead of reflection for better performance
-                PDFFile pdfFileCopy = new PDFFile();
-                pdfFileCopy.setFileId(pdfFile.getFileId());
-                pdfFileCopy.setFileInput(pdfFile.getFileInput());
-
-                // Case 1: fileId is provided but no fileInput
-                if (pdfFileCopy.getFileInput() == null && pdfFileCopy.getFileId() != null) {
-                    try {
-                        log.debug("Using fileId {} to get file content", pdfFileCopy.getFileId());
-                        MultipartFile file = fileStorage.retrieveFile(pdfFileCopy.getFileId());
-                        pdfFileCopy.setFileInput(file);
-                    } catch (Exception e) {
-                        throw new RuntimeException(
-                                "Failed to resolve file by ID: " + pdfFileCopy.getFileId(), e);
-                    }
-                }
-                // Case 2: For async requests, we need to make a copy of the MultipartFile
-                else if (async && pdfFileCopy.getFileInput() != null) {
-                    try {
-                        log.debug("Making persistent copy of uploaded file for async processing");
-                        MultipartFile originalFile = pdfFileCopy.getFileInput();
-                        String fileId = fileStorage.storeFile(originalFile);
-
-                        // Store the fileId for later reference
-                        pdfFileCopy.setFileId(fileId);
-
-                        // Replace the original MultipartFile with our persistent copy
-                        MultipartFile persistentFile = fileStorage.retrieveFile(fileId);
-                        pdfFileCopy.setFileInput(persistentFile);
-
-                        log.debug("Created persistent file copy with fileId: {}", fileId);
-                    } catch (IOException e) {
-                        throw new RuntimeException(
-                                "Failed to create persistent copy of uploaded file", e);
-                    }
-                }
-
-                processedArgs[i] = pdfFileCopy;
-            } else {
-                // For non-PDFFile objects, just pass the original reference
-                // If other classes need copy-on-write, add them here
-                processedArgs[i] = arg;
-            }
-        }
-
-        return processedArgs;
-    }
 
     /**
-     * Processes arguments in-place for testing purposes This is similar to our original
-     * implementation before introducing copy-on-write It's only used in test environments to
-     * maintain test compatibility
+     * Processes arguments in-place to handle file resolution and async file persistence.
+     * This approach avoids type mismatch issues by modifying the original objects directly.
      *
      * @param originalArgs The original arguments
      * @param async Whether this is an async operation

common/src/main/java/stirling/software/common/model/job/JobResult.java

@@ -6,6 +6,8 @@ import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
+
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
@@ -28,6 +30,7 @@ public class JobResult {
     private String error;
 
     /** List of result files for jobs that produce files */
+    @JsonIgnore
     private List<ResultFile> resultFiles;
 
     /** Time when the job was created */

common/src/main/java/stirling/software/common/service/TaskManager.java

@@ -1,6 +1,5 @@
 package stirling.software.common.service;
 
-import io.github.pixee.security.ZipSecurity;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -21,6 +20,8 @@ import org.springframework.http.MediaType;
 import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
 
+import io.github.pixee.security.ZipSecurity;
+
 import jakarta.annotation.PreDestroy;
 
 import lombok.extern.slf4j.Slf4j;
@@ -361,7 +362,8 @@ public class TaskManager {
         MultipartFile zipFile = fileStorage.retrieveFile(zipFileId);
 
         try (ZipInputStream zipIn =
-                ZipSecurity.createHardenedInputStream(new ByteArrayInputStream(zipFile.getBytes()))) {
+                ZipSecurity.createHardenedInputStream(
+                        new ByteArrayInputStream(zipFile.getBytes()))) {
             ZipEntry entry;
             while ((entry = zipIn.getNextEntry()) != null) {
                 if (!entry.isDirectory()) {

stirling-pdf/src/main/java/stirling/software/SPDF/config/CleanUrlInterceptor.java

@@ -29,7 +29,8 @@ public class CleanUrlInterceptor implements HandlerInterceptor {
                     "type",
                     "principal",
                     "startDate",
-                    "endDate");
+                    "endDate",
+                    "async");
 
     @Override
     public boolean preHandle(