PDF Text editor (#4724)

## Summary - add a `PdfJsonConversionService` that serializes PDF text, fonts, and metadata to JSON and rebuilds a PDF from the same structure - expose REST endpoints for `/pdf/json` and `/json/pdf` conversions using the existing convert API infrastructure - define JSON model classes capturing document metadata, font information, and positioned text elements ## Testing - `./gradlew spotlessApply` *(fails: plugin org.springframework.boot:3.5.4 unavailable in build environment)* - `./gradlew build` *(fails: plugin org.springframework.boot:3.5.4 unavailable in build environment)* ------ https://chatgpt.com/codex/tasks/task_b_68f8e98d94ac8328a0e499e541528b6f --------- Co-authored-by: EthanHealy01 <[email protected]>
2026-07-15 02:54:06 +02:00 · 2025-11-24 14:15:02 +00:00
parent d42065e338
commit b0397da19e
253 changed files with 26069 additions and 111 deletions
@@ -0,0 +1,602 @@
+package stirling.software.SPDF.config;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Service;
+
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+
+import stirling.software.common.model.ApplicationProperties;
+
+@Service
+@Slf4j
+public class EndpointConfiguration {
+
+    public enum DisableReason {
+        CONFIG,
+        DEPENDENCY,
+        UNKNOWN
+    }
+
+    public static class EndpointAvailability {
+        private final boolean enabled;
+        private final DisableReason reason;
+
+        public EndpointAvailability(boolean enabled, DisableReason reason) {
+            this.enabled = enabled;
+            this.reason = reason;
+        }
+
+        public boolean isEnabled() {
+            return enabled;
+        }
+
+        public DisableReason getReason() {
+            return reason;
+        }
+    }
+
+    private static final String REMOVE_BLANKS = "remove-blanks";
+    private final ApplicationProperties applicationProperties;
+    @Getter private Map<String, Boolean> endpointStatuses = new ConcurrentHashMap<>();
+    private Map<String, Set<String>> endpointGroups = new ConcurrentHashMap<>();
+    private Set<String> disabledGroups = new HashSet<>();
+    private Map<String, DisableReason> endpointDisableReasons = new ConcurrentHashMap<>();
+    private Map<String, DisableReason> groupDisableReasons = new ConcurrentHashMap<>();
+    private Map<String, Set<String>> endpointAlternatives = new ConcurrentHashMap<>();
+    private final boolean runningProOrHigher;
+
+    public EndpointConfiguration(
+            ApplicationProperties applicationProperties,
+            @Qualifier("runningProOrHigher") boolean runningProOrHigher) {
+        this.applicationProperties = applicationProperties;
+        this.runningProOrHigher = runningProOrHigher;
+        init();
+        processEnvironmentConfigs();
+    }
+
+    private String normalizeEndpoint(String endpoint) {
+        if (endpoint == null) {
+            return null;
+        }
+        return endpoint.startsWith("/") ? endpoint.substring(1) : endpoint;
+    }
+
+    public void enableEndpoint(String endpoint) {
+        String normalized = normalizeEndpoint(endpoint);
+        endpointStatuses.put(normalized, true);
+        endpointDisableReasons.remove(normalized);
+        log.debug("Enabled endpoint: {}", normalized);
+    }
+
+    public void disableEndpoint(String endpoint) {
+        disableEndpoint(endpoint, DisableReason.CONFIG);
+    }
+
+    public void disableEndpoint(String endpoint, DisableReason reason) {
+        String normalized = normalizeEndpoint(endpoint);
+        if (!Boolean.FALSE.equals(endpointStatuses.get(normalized))) {
+            log.debug("Disabling endpoint: {}", normalized);
+        }
+        endpointStatuses.put(normalized, false);
+        endpointDisableReasons.put(normalized, reason);
+    }
+
+    public boolean isEndpointEnabled(String endpoint) {
+        String original = endpoint;
+        if (endpoint.startsWith("/")) {
+            endpoint = endpoint.substring(1);
+        }
+
+        // Rule 1: Explicit flag wins - if disabled via disableEndpoint(), stay disabled
+        Boolean explicitStatus = endpointStatuses.get(endpoint);
+        if (Boolean.FALSE.equals(explicitStatus)) {
+            log.debug("isEndpointEnabled('{}') -> false (explicitly disabled)", original);
+            return false;
+        }
+
+        // Rule 2: Functional-group override - check if endpoint belongs to any disabled functional
+        // group
+        for (String group : endpointGroups.keySet()) {
+            if (disabledGroups.contains(group) && endpointGroups.get(group).contains(endpoint)) {
+                // Skip tool groups (qpdf, OCRmyPDF, Ghostscript, LibreOffice, etc.)
+                if (!isToolGroup(group)) {
+                    log.debug(
+                            "isEndpointEnabled('{}') -> false (functional group '{}' disabled)",
+                            original,
+                            group);
+                    return false;
+                }
+            }
+        }
+
+        // Rule 3: Tool-group fallback - check if at least one alternative tool group is enabled
+        Set<String> alternatives = endpointAlternatives.get(endpoint);
+        if (alternatives != null && !alternatives.isEmpty()) {
+            boolean hasEnabledToolGroup =
+                    alternatives.stream()
+                            .anyMatch(toolGroup -> !disabledGroups.contains(toolGroup));
+            log.debug(
+                    "isEndpointEnabled('{}') -> {} (tool groups check)",
+                    original,
+                    hasEnabledToolGroup);
+            return hasEnabledToolGroup;
+        }
+
+        // Rule 4: Single-dependency check - if no alternatives defined, check if endpoint belongs
+        // to any disabled tool groups
+        for (String group : endpointGroups.keySet()) {
+            if (isToolGroup(group)
+                    && disabledGroups.contains(group)
+                    && endpointGroups.get(group).contains(endpoint)) {
+                log.debug(
+                        "isEndpointEnabled('{}') -> false (single tool group '{}' disabled, no alternatives)",
+                        original,
+                        group);
+                return false;
+            }
+        }
+
+        // Default: enabled if not explicitly disabled
+        boolean enabled = !Boolean.FALSE.equals(explicitStatus);
+        log.debug("isEndpointEnabled('{}') -> {} (default)", original, enabled);
+        return enabled;
+    }
+
+    public boolean isGroupEnabled(String group) {
+        // Rule 1: If group is explicitly disabled, it stays disabled
+        if (disabledGroups.contains(group)) {
+            log.debug("isGroupEnabled('{}') -> false (explicitly disabled)", group);
+            return false;
+        }
+
+        Set<String> endpoints = endpointGroups.get(group);
+        if (endpoints == null || endpoints.isEmpty()) {
+            log.debug("isGroupEnabled('{}') -> false (no endpoints)", group);
+            return false;
+        }
+
+        // Rule 2: For functional groups, check if all endpoints are enabled
+        // Rule 3: For tool groups, they're enabled unless explicitly disabled (handled above)
+        if (isToolGroup(group)) {
+            log.debug("isGroupEnabled('{}') -> true (tool group not disabled)", group);
+            return true;
+        }
+
+        // For functional groups, check each endpoint individually
+        for (String endpoint : endpoints) {
+            if (!isEndpointEnabledDirectly(endpoint)) {
+                log.debug(
+                        "isGroupEnabled('{}') -> false (endpoint '{}' disabled)", group, endpoint);
+                return false;
+            }
+        }
+
+        log.debug("isGroupEnabled('{}') -> true (all endpoints enabled)", group);
+        return true;
+    }
+
+    public void addEndpointToGroup(String group, String endpoint) {
+        endpointGroups.computeIfAbsent(group, k -> new HashSet<>()).add(endpoint);
+    }
+
+    public void addEndpointAlternative(String endpoint, String toolGroup) {
+        endpointAlternatives.computeIfAbsent(endpoint, k -> new HashSet<>()).add(toolGroup);
+    }
+
+    public void disableGroup(String group) {
+        disableGroup(group, DisableReason.CONFIG);
+    }
+
+    public void disableGroup(String group, DisableReason reason) {
+        if (disabledGroups.add(group)) {
+            if (isToolGroup(group)) {
+                log.debug(
+                        "Disabling tool group: {} (endpoints with alternatives remain available)",
+                        group);
+            } else {
+                log.debug(
+                        "Disabling functional group: {} (will disable all endpoints in group)",
+                        group);
+            }
+        }
+        groupDisableReasons.put(group, reason);
+        // Only cascade to endpoints for *functional* groups
+        if (!isToolGroup(group)) {
+            Set<String> endpoints = endpointGroups.get(group);
+            if (endpoints != null) {
+                endpoints.forEach(endpoint -> disableEndpoint(endpoint, reason));
+            }
+        }
+    }
+
+    public void enableGroup(String group) {
+        if (disabledGroups.remove(group)) {
+            log.debug("Enabling group: {}", group);
+        }
+        groupDisableReasons.remove(group);
+        Set<String> endpoints = endpointGroups.get(group);
+        if (endpoints != null) {
+            endpoints.forEach(this::enableEndpoint);
+        }
+    }
+
+    public EndpointAvailability getEndpointAvailability(String endpoint) {
+        boolean enabled = isEndpointEnabled(endpoint);
+        DisableReason reason = enabled ? null : determineDisableReason(endpoint);
+        return new EndpointAvailability(enabled, reason);
+    }
+
+    private DisableReason determineDisableReason(String endpoint) {
+        String normalized = normalizeEndpoint(endpoint);
+        if (Boolean.FALSE.equals(endpointStatuses.get(normalized))) {
+            return endpointDisableReasons.getOrDefault(normalized, DisableReason.CONFIG);
+        }
+
+        for (Map.Entry<String, Set<String>> entry : endpointGroups.entrySet()) {
+            String group = entry.getKey();
+            Set<String> endpoints = entry.getValue();
+            if (!disabledGroups.contains(group) || endpoints == null) {
+                continue;
+            }
+            if (endpoints.contains(normalized)) {
+                return groupDisableReasons.getOrDefault(group, DisableReason.CONFIG);
+            }
+        }
+
+        return DisableReason.UNKNOWN;
+    }
+
+    public Set<String> getDisabledGroups() {
+        return new HashSet<>(disabledGroups);
+    }
+
+    public void logDisabledEndpointsSummary() {
+        // Get all unique endpoints across all groups
+        Set<String> allEndpoints =
+                endpointGroups.values().stream()
+                        .flatMap(Set::stream)
+                        .collect(java.util.stream.Collectors.toSet());
+
+        // Check which endpoints are actually disabled (functionally unavailable)
+        List<String> functionallyDisabledEndpoints =
+                allEndpoints.stream()
+                        .filter(endpoint -> !isEndpointEnabled(endpoint))
+                        .sorted()
+                        .toList();
+
+        // Separate tool groups from functional groups
+        List<String> disabledToolGroups =
+                disabledGroups.stream().filter(this::isToolGroup).sorted().toList();
+
+        List<String> disabledFunctionalGroups =
+                disabledGroups.stream().filter(group -> !isToolGroup(group)).sorted().toList();
+
+        if (!disabledToolGroups.isEmpty()) {
+            log.info(
+                    "Disabled tool groups: {} (endpoints may have alternative implementations)",
+                    String.join(", ", disabledToolGroups));
+        }
+
+        if (!disabledFunctionalGroups.isEmpty()) {
+            log.info("Disabled functional groups: {}", String.join(", ", disabledFunctionalGroups));
+        }
+
+        if (!functionallyDisabledEndpoints.isEmpty()) {
+            log.info(
+                    "Total disabled endpoints: {}. Disabled endpoints: {}",
+                    functionallyDisabledEndpoints.size(),
+                    String.join(", ", functionallyDisabledEndpoints));
+        } else if (!disabledToolGroups.isEmpty()) {
+            log.info(
+                    "No endpoints disabled despite missing tools - fallback implementations available");
+        }
+    }
+
+    public void init() {
+        // Adding endpoints to "PageOps" group
+        addEndpointToGroup("PageOps", "remove-pages");
+        addEndpointToGroup("PageOps", "merge-pdfs");
+        addEndpointToGroup("PageOps", "split-pdfs");
+        addEndpointToGroup("PageOps", "pdf-organizer");
+        addEndpointToGroup("PageOps", "rotate-pdf");
+        addEndpointToGroup("PageOps", "multi-page-layout");
+        addEndpointToGroup("PageOps", "booklet-imposition");
+        addEndpointToGroup("PageOps", "scale-pages");
+        addEndpointToGroup("PageOps", "crop");
+        addEndpointToGroup("PageOps", "extract-page");
+        addEndpointToGroup("PageOps", "pdf-to-single-page");
+        addEndpointToGroup("PageOps", "auto-split-pdf");
+        addEndpointToGroup("PageOps", "split-by-size-or-count");
+        addEndpointToGroup("PageOps", "overlay-pdf");
+        addEndpointToGroup("PageOps", "split-pdf-by-sections");
+        addEndpointToGroup("PageOps", "split-pdf-by-chapters");
+
+        // Adding endpoints to "Convert" group
+        addEndpointToGroup("Convert", "pdf-to-img");
+        addEndpointToGroup("Convert", "img-to-pdf");
+        addEndpointToGroup("Convert", "pdf-to-pdfa");
+        addEndpointToGroup("Convert", "file-to-pdf");
+        addEndpointToGroup("Convert", "pdf-to-word");
+        addEndpointToGroup("Convert", "pdf-to-presentation");
+        addEndpointToGroup("Convert", "pdf-to-text");
+        addEndpointToGroup("Convert", "pdf-to-html");
+        addEndpointToGroup("Convert", "pdf-to-xml");
+        addEndpointToGroup("Convert", "html-to-pdf");
+        addEndpointToGroup("Convert", "url-to-pdf");
+        addEndpointToGroup("Convert", "markdown-to-pdf");
+        addEndpointToGroup("Convert", "pdf-to-csv");
+        addEndpointToGroup("Convert", "pdf-to-markdown");
+        addEndpointToGroup("Convert", "eml-to-pdf");
+        addEndpointToGroup("Convert", "cbz-to-pdf");
+        addEndpointToGroup("Convert", "pdf-to-cbz");
+        addEndpointToGroup("Convert", "pdf-to-json");
+        addEndpointToGroup("Convert", "json-to-pdf");
+
+        // Adding endpoints to "Security" group
+        addEndpointToGroup("Security", "add-password");
+        addEndpointToGroup("Security", "remove-password");
+        addEndpointToGroup("Security", "change-permissions");
+        addEndpointToGroup("Security", "add-watermark");
+        addEndpointToGroup("Security", "cert-sign");
+        addEndpointToGroup("Security", "remove-cert-sign");
+        addEndpointToGroup("Security", "sanitize-pdf");
+        addEndpointToGroup("Security", "auto-redact");
+        addEndpointToGroup("Security", "redact");
+        addEndpointToGroup("Security", "validate-signature");
+        addEndpointToGroup("Security", "stamp");
+        addEndpointToGroup("Security", "sign");
+
+        // Adding endpoints to "Other" group
+        addEndpointToGroup("Other", "ocr-pdf");
+        addEndpointToGroup("Other", "add-image");
+        addEndpointToGroup("Other", "extract-images");
+        addEndpointToGroup("Other", "change-metadata");
+        addEndpointToGroup("Other", "flatten");
+        addEndpointToGroup("Other", "unlock-pdf-forms");
+        addEndpointToGroup("Other", REMOVE_BLANKS);
+        addEndpointToGroup("Other", "remove-annotations");
+        addEndpointToGroup("Other", "compare");
+        addEndpointToGroup("Other", "add-page-numbers");
+        addEndpointToGroup("Other", "get-info-on-pdf");
+        addEndpointToGroup("Other", "remove-image-pdf");
+        addEndpointToGroup("Other", "add-attachments");
+        addEndpointToGroup("Other", "view-pdf");
+        addEndpointToGroup("Other", "replace-and-invert-color-pdf");
+        addEndpointToGroup("Other", "multi-tool");
+
+        // Adding form-related endpoints to "Other" group
+        addEndpointToGroup("Other", "fields");
+        addEndpointToGroup("Other", "modify-fields");
+        addEndpointToGroup("Other", "delete-fields");
+        addEndpointToGroup("Other", "fill");
+
+        // Adding endpoints to "Advance" group
+        addEndpointToGroup("Advance", "adjust-contrast");
+        addEndpointToGroup("Advance", "compress-pdf");
+        addEndpointToGroup("Advance", "extract-image-scans");
+        addEndpointToGroup("Advance", "repair");
+        addEndpointToGroup("Advance", "auto-rename");
+        addEndpointToGroup("Advance", "pipeline");
+        addEndpointToGroup("Advance", "scanner-effect");
+        addEndpointToGroup("Advance", "auto-split-pdf");
+        addEndpointToGroup("Advance", "show-javascript");
+        addEndpointToGroup("Advance", "split-by-size-or-count");
+        addEndpointToGroup("Advance", "overlay-pdf");
+        addEndpointToGroup("Advance", "split-pdf-by-sections");
+        addEndpointToGroup("Advance", "edit-table-of-contents");
+        addEndpointToGroup("Advance", "split-pdf-by-chapters");
+
+        // CLI
+        addEndpointToGroup("CLI", "compress-pdf");
+        addEndpointToGroup("CLI", "extract-image-scans");
+        addEndpointToGroup("CLI", "repair");
+        addEndpointToGroup("CLI", "pdf-to-pdfa");
+        addEndpointToGroup("CLI", "file-to-pdf");
+        addEndpointToGroup("CLI", "pdf-to-word");
+        addEndpointToGroup("CLI", "pdf-to-presentation");
+        addEndpointToGroup("CLI", "pdf-to-html");
+        addEndpointToGroup("CLI", "pdf-to-xml");
+        addEndpointToGroup("CLI", "ocr-pdf");
+        addEndpointToGroup("CLI", "html-to-pdf");
+        addEndpointToGroup("CLI", "url-to-pdf");
+        addEndpointToGroup("CLI", "pdf-to-rtf");
+
+        // python
+        addEndpointToGroup("Python", "extract-image-scans");
+        addEndpointToGroup("Python", "html-to-pdf");
+        addEndpointToGroup("Python", "url-to-pdf");
+        addEndpointToGroup("Python", "file-to-pdf");
+
+        // openCV
+        addEndpointToGroup("OpenCV", "extract-image-scans");
+
+        // LibreOffice
+        addEndpointToGroup("LibreOffice", "file-to-pdf");
+        addEndpointToGroup("LibreOffice", "pdf-to-word");
+        addEndpointToGroup("LibreOffice", "pdf-to-presentation");
+        addEndpointToGroup("LibreOffice", "pdf-to-rtf");
+        addEndpointToGroup("LibreOffice", "pdf-to-html");
+        addEndpointToGroup("LibreOffice", "pdf-to-xml");
+        addEndpointToGroup("LibreOffice", "pdf-to-pdfa");
+
+        // Unoconvert
+        addEndpointToGroup("Unoconvert", "file-to-pdf");
+
+        // Java
+        addEndpointToGroup("Java", "merge-pdfs");
+        addEndpointToGroup("Java", "remove-pages");
+        addEndpointToGroup("Java", "split-pdfs");
+        addEndpointToGroup("Java", "pdf-organizer");
+        addEndpointToGroup("Java", "rotate-pdf");
+        addEndpointToGroup("Java", "pdf-to-img");
+        addEndpointToGroup("Java", "img-to-pdf");
+        addEndpointToGroup("Java", "add-password");
+        addEndpointToGroup("Java", "remove-password");
+        addEndpointToGroup("Java", "change-permissions");
+        addEndpointToGroup("Java", "add-watermark");
+        addEndpointToGroup("Java", "add-image");
+        addEndpointToGroup("Java", "extract-images");
+        addEndpointToGroup("Java", "change-metadata");
+        addEndpointToGroup("Java", "cert-sign");
+        addEndpointToGroup("Java", "remove-cert-sign");
+        addEndpointToGroup("Java", "multi-page-layout");
+        addEndpointToGroup("Java", "booklet-imposition");
+        addEndpointToGroup("Java", "scale-pages");
+        addEndpointToGroup("Java", "add-page-numbers");
+        addEndpointToGroup("Java", "auto-rename");
+        addEndpointToGroup("Java", "auto-split-pdf");
+        addEndpointToGroup("Java", "sanitize-pdf");
+        addEndpointToGroup("Java", "crop");
+        addEndpointToGroup("Java", "get-info-on-pdf");
+        addEndpointToGroup("Java", "extract-page");
+        addEndpointToGroup("Java", "pdf-to-single-page");
+        addEndpointToGroup("Java", "markdown-to-pdf");
+        addEndpointToGroup("Java", "show-javascript");
+        addEndpointToGroup("Java", "auto-redact");
+        addEndpointToGroup("Java", "redact");
+        addEndpointToGroup("Java", "pdf-to-csv");
+        addEndpointToGroup("Java", "split-by-size-or-count");
+        addEndpointToGroup("Java", "overlay-pdf");
+        addEndpointToGroup("Java", "split-pdf-by-sections");
+        addEndpointToGroup("Java", REMOVE_BLANKS);
+        addEndpointToGroup("Java", "pdf-to-text");
+        addEndpointToGroup("Java", "remove-image-pdf");
+        addEndpointToGroup("Java", "pdf-to-markdown");
+        addEndpointToGroup("Java", "add-attachments");
+        addEndpointToGroup("Java", "compress-pdf");
+        addEndpointToGroup("Java", "cbz-to-pdf");
+        addEndpointToGroup("Java", "pdf-to-cbz");
+        addEndpointToGroup("Java", "pdf-to-json");
+        addEndpointToGroup("Java", "json-to-pdf");
+        addEndpointToGroup("rar", "pdf-to-cbr");
+
+        // Javascript
+        addEndpointToGroup("Javascript", "pdf-organizer");
+        addEndpointToGroup("Javascript", "sign");
+        addEndpointToGroup("Javascript", "compare");
+        addEndpointToGroup("Javascript", "adjust-contrast");
+
+        /* qpdf */
+        addEndpointToGroup("qpdf", "repair");
+        addEndpointToGroup("qpdf", "compress-pdf");
+
+        /* Ghostscript */
+        addEndpointToGroup("Ghostscript", "repair");
+        addEndpointToGroup("Ghostscript", "compress-pdf");
+
+        /* tesseract */
+        addEndpointToGroup("tesseract", "ocr-pdf");
+
+        /* OCRmyPDF */
+        addEndpointToGroup("OCRmyPDF", "ocr-pdf");
+
+        // Multi-tool endpoints - endpoints that can be handled by multiple tools
+        addEndpointAlternative("repair", "qpdf");
+        addEndpointAlternative("repair", "Ghostscript");
+        addEndpointAlternative("compress-pdf", "qpdf");
+        addEndpointAlternative("compress-pdf", "Ghostscript");
+        addEndpointAlternative("compress-pdf", "Java");
+        addEndpointAlternative("ocr-pdf", "tesseract");
+        addEndpointAlternative("ocr-pdf", "OCRmyPDF");
+
+        // file-to-pdf has multiple implementations
+        addEndpointAlternative("file-to-pdf", "LibreOffice");
+        addEndpointAlternative("file-to-pdf", "Unoconvert");
+
+        // pdf-to-html and pdf-to-markdown can use either LibreOffice or Pdftohtml
+        addEndpointAlternative("pdf-to-html", "LibreOffice");
+        addEndpointAlternative("pdf-to-html", "Pdftohtml");
+        addEndpointAlternative("pdf-to-markdown", "Pdftohtml");
+
+        // markdown-to-pdf can use either Weasyprint or Java
+        addEndpointAlternative("markdown-to-pdf", "Weasyprint");
+        addEndpointAlternative("markdown-to-pdf", "Java");
+
+        // Weasyprint dependent endpoints
+        addEndpointToGroup("Weasyprint", "html-to-pdf");
+        addEndpointToGroup("Weasyprint", "url-to-pdf");
+        addEndpointToGroup("Weasyprint", "markdown-to-pdf");
+        addEndpointToGroup("Weasyprint", "eml-to-pdf");
+
+        // Pdftohtml dependent endpoints
+        addEndpointToGroup("Pdftohtml", "pdf-to-html");
+        addEndpointToGroup("Pdftohtml", "pdf-to-markdown");
+    }
+
+    private void processEnvironmentConfigs() {
+        if (applicationProperties != null && applicationProperties.getEndpoints() != null) {
+            List<String> endpointsToRemove = applicationProperties.getEndpoints().getToRemove();
+            List<String> groupsToRemove = applicationProperties.getEndpoints().getGroupsToRemove();
+
+            if (endpointsToRemove != null) {
+                for (String endpoint : endpointsToRemove) {
+                    disableEndpoint(endpoint.trim());
+                }
+            }
+
+            if (groupsToRemove != null) {
+                for (String group : groupsToRemove) {
+                    disableGroup(group.trim());
+                }
+            }
+        }
+        if (!runningProOrHigher) {
+            disableGroup("enterprise");
+        }
+
+        if (!applicationProperties.getSystem().getEnableUrlToPDF()) {
+            disableEndpoint("url-to-pdf");
+        }
+    }
+
+    public Set<String> getEndpointsForGroup(String group) {
+        return endpointGroups.getOrDefault(group, new HashSet<>());
+    }
+
+    private boolean isToolGroup(String group) {
+        return "qpdf".equals(group)
+                || "OCRmyPDF".equals(group)
+                || "Ghostscript".equals(group)
+                || "LibreOffice".equals(group)
+                || "tesseract".equals(group)
+                || "CLI".equals(group)
+                || "Python".equals(group)
+                || "OpenCV".equals(group)
+                || "Unoconvert".equals(group)
+                || "Java".equals(group)
+                || "Javascript".equals(group)
+                || "Weasyprint".equals(group)
+                || "Pdftohtml".equals(group)
+                || "rar".equals(group);
+    }
+
+    private boolean isEndpointEnabledDirectly(String endpoint) {
+        if (endpoint.startsWith("/")) {
+            endpoint = endpoint.substring(1);
+        }
+
+        // Check explicit disable flag
+        Boolean explicitStatus = endpointStatuses.get(endpoint);
+        if (Boolean.FALSE.equals(explicitStatus)) {
+            return false;
+        }
+
+        // Check if endpoint belongs to any disabled functional group
+        for (String group : endpointGroups.keySet()) {
+            if (disabledGroups.contains(group) && endpointGroups.get(group).contains(endpoint)) {
+                if (!isToolGroup(group)) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+}
@@ -0,0 +1,30 @@
+package stirling.software.SPDF.config.swagger;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Schema(description = "Standard error response")
+public class ErrorResponse {
+
+    @Schema(description = "HTTP status code", example = "400")
+    private int status;
+
+    @Schema(
+            description = "Error message describing what went wrong",
+            example = "Invalid PDF file or corrupted data")
+    private String message;
+
+    @Schema(description = "Timestamp when the error occurred", example = "2024-01-15T10:30:00Z")
+    private String timestamp;
+
+    @Schema(
+            description = "Request path where the error occurred",
+            example = "/api/v1/{endpoint-path}")
+    private String path;
+}
@@ -0,0 +1,47 @@
+package stirling.software.SPDF.config.swagger;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+
+/**
+ * Standard API response annotation for PDF operations that take PDF input and return PDF output.
+ * Use for single PDF input → single PDF output (SISO) operations like rotate, compress, etc.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+@ApiResponses(
+        value = {
+            @ApiResponse(
+                    responseCode = "200",
+                    description = "PDF processed successfully",
+                    content =
+                            @Content(
+                                    mediaType = "application/pdf",
+                                    schema =
+                                            @Schema(
+                                                    type = "string",
+                                                    format = "binary",
+                                                    description = "The processed PDF file"))),
+            @ApiResponse(
+                    responseCode = "400",
+                    description = "Invalid PDF file or request parameters",
+                    content =
+                            @Content(
+                                    mediaType = "application/json",
+                                    schema = @Schema(implementation = ErrorResponse.class))),
+            @ApiResponse(
+                    responseCode = "500",
+                    description = "Internal server error during processing",
+                    content =
+                            @Content(
+                                    mediaType = "application/json",
+                                    schema = @Schema(implementation = ErrorResponse.class)))
+        })
+public @interface StandardPdfResponse {}
@@ -41,7 +41,7 @@ public class CustomPDFDocumentFactory {

    // Memory thresholds and limits

-    private static final long SMALL_FILE_THRESHOLD = 10 * 1024 * 1024; // 10 MB
+    public static final long SMALL_FILE_THRESHOLD = 10 * 1024 * 1024; // 10 MB
    // Files smaller than this threshold are loaded entirely in memory for better performance.
    // These files use IOUtils.createMemoryOnlyStreamCache() which keeps all document data in RAM.
    // No temp files are created for document data, reducing I/O operations but consuming more
@@ -9,6 +9,7 @@ import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.function.Supplier;

+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.MediaType;
@@ -37,6 +38,9 @@ public class JobExecutorService {
    private final ExecutorService executor = ExecutorFactory.newVirtualOrCachedThreadExecutor();
    private final long effectiveTimeoutMs;

+    @Autowired(required = false)
+    private JobOwnershipService jobOwnershipService;
+
    public JobExecutorService(
            TaskManager taskManager,
            FileStorage fileStorage,
@@ -98,11 +102,17 @@ public class JobExecutorService {
            long customTimeoutMs,
            boolean queueable,
            int resourceWeight) {
-        String jobId = UUID.randomUUID().toString();
+        // Generate base UUID
+        String baseJobId = UUID.randomUUID().toString();

-        // Store the job ID in the request for potential use by other components
+        // Scope job to authenticated user if security is enabled
+        String scopedJobKey = getScopedJobKey(baseJobId);
+
+        log.debug("Generated jobId: {} (base: {})", scopedJobKey, baseJobId);
+
+        // Store the scoped job ID in the request for potential use by other components
        if (request != null) {
-            request.setAttribute("jobId", jobId);
+            request.setAttribute("jobId", scopedJobKey);

            // Also track this job ID in the user's session for authorization purposes
            // This ensures users can only cancel their own jobs
@@ -116,11 +126,13 @@ public class JobExecutorService {
                    request.getSession().setAttribute("userJobIds", userJobIds);
                }

-                userJobIds.add(jobId);
-                log.debug("Added job ID {} to user session", jobId);
+                userJobIds.add(scopedJobKey);
+                log.debug("Added scoped job ID {} to user session", scopedJobKey);
            }
        }

+        String jobId = scopedJobKey;
+
        // Determine which timeout to use
        long timeoutToUse = customTimeoutMs > 0 ? customTimeoutMs : effectiveTimeoutMs;

@@ -149,17 +161,31 @@ public class JobExecutorService {
            taskManager.createTask(jobId);

            // Create a specialized wrapper that updates the TaskManager
+            final String capturedJobIdForQueue = jobId;
            Supplier<Object> wrappedWork =
                    () -> {
                        try {
+                            // Set jobId in ThreadLocal context for the queued job
+                            stirling.software.common.util.JobContext.setJobId(
+                                    capturedJobIdForQueue);
+                            log.debug(
+                                    "Set jobId {} in JobContext for queued job execution",
+                                    capturedJobIdForQueue);
+
                            Object result = work.get();
-                            processJobResult(jobId, result);
+                            processJobResult(capturedJobIdForQueue, result);
                            return result;
                        } catch (Exception e) {
                            log.error(
-                                    "Error executing queued job {}: {}", jobId, e.getMessage(), e);
-                            taskManager.setError(jobId, e.getMessage());
+                                    "Error executing queued job {}: {}",
+                                    capturedJobIdForQueue,
+                                    e.getMessage(),
+                                    e);
+                            taskManager.setError(capturedJobIdForQueue, e.getMessage());
                            throw e;
+                        } finally {
+                            // Clean up ThreadLocal to avoid memory leaks
+                            stirling.software.common.util.JobContext.clear();
                        }
                    };

@@ -171,21 +197,36 @@ public class JobExecutorService {
            return ResponseEntity.ok().body(new JobResponse<>(true, jobId, null));
        } else if (async) {
            taskManager.createTask(jobId);
+
+            // Capture the jobId for the async thread
+            final String capturedJobId = jobId;
+
            executor.execute(
                    () -> {
                        try {
                            log.debug(
-                                    "Running async job {} with timeout {} ms", jobId, timeoutToUse);
+                                    "Running async job {} with timeout {} ms",
+                                    capturedJobId,
+                                    timeoutToUse);
+
+                            // Set jobId in ThreadLocal context for the async thread
+                            stirling.software.common.util.JobContext.setJobId(capturedJobId);
+                            log.debug(
+                                    "Set jobId {} in JobContext for async execution",
+                                    capturedJobId);

                            // Execute with timeout
                            Object result = executeWithTimeout(() -> work.get(), timeoutToUse);
-                            processJobResult(jobId, result);
+                            processJobResult(capturedJobId, result);
                        } catch (TimeoutException te) {
                            log.error("Job {} timed out after {} ms", jobId, timeoutToUse);
                            taskManager.setError(jobId, "Job timed out");
                        } catch (Exception e) {
                            log.error("Error executing job {}: {}", jobId, e.getMessage(), e);
                            taskManager.setError(jobId, e.getMessage());
+                        } finally {
+                            // Clean up ThreadLocal to avoid memory leaks
+                            stirling.software.common.util.JobContext.clear();
                        }
                    });

@@ -194,6 +235,10 @@ public class JobExecutorService {
            try {
                log.debug("Running sync job with timeout {} ms", timeoutToUse);

+                // Make jobId available to downstream components on the worker thread
+                stirling.software.common.util.JobContext.setJobId(jobId);
+                log.debug("Set jobId {} in JobContext for sync execution", jobId);
+
                // Execute with timeout
                Object result = executeWithTimeout(() -> work.get(), timeoutToUse);

@@ -213,6 +258,8 @@ public class JobExecutorService {
                // Construct a JSON error response
                return ResponseEntity.internalServerError()
                        .body(Map.of("error", "Job failed: " + e.getMessage()));
+            } finally {
+                stirling.software.common.util.JobContext.clear();
            }
        }
    }
@@ -466,8 +513,23 @@ public class JobExecutorService {
            throws TimeoutException, Exception {
        // Use the same executor as other async jobs for consistency
        // This ensures all operations run on the same thread pool
+        String currentJobId = stirling.software.common.util.JobContext.getJobId();
+
        java.util.concurrent.CompletableFuture<T> future =
-                java.util.concurrent.CompletableFuture.supplyAsync(supplier, executor);
+                java.util.concurrent.CompletableFuture.supplyAsync(
+                        () -> {
+                            if (currentJobId != null) {
+                                stirling.software.common.util.JobContext.setJobId(currentJobId);
+                            }
+                            try {
+                                return supplier.get();
+                            } finally {
+                                if (currentJobId != null) {
+                                    stirling.software.common.util.JobContext.clear();
+                                }
+                            }
+                        },
+                        executor);

        try {
            return future.get(timeoutMs, TimeUnit.MILLISECONDS);
@@ -483,4 +545,18 @@ public class JobExecutorService {
            throw new Exception("Execution was interrupted", e);
        }
    }
+
+    /**
+     * Get a scoped job key that includes user ownership when security is enabled.
+     *
+     * @param baseJobId the base job identifier
+     * @return scoped job key, or just baseJobId if no ownership service available
+     */
+    private String getScopedJobKey(String baseJobId) {
+        if (jobOwnershipService != null) {
+            return jobOwnershipService.createScopedJobKey(baseJobId);
+        }
+        // Security disabled, return unsecured job key
+        return baseJobId;
+    }
 }
@@ -0,0 +1,42 @@
+package stirling.software.common.service;
+
+import java.util.Optional;
+
+/**
+ * Service interface for managing job ownership and access control. Implementations can provide
+ * user-scoped job isolation when security is enabled, or no-op behavior when security is disabled.
+ */
+public interface JobOwnershipService {
+
+    /**
+     * Get the current authenticated user's identifier.
+     *
+     * @return Optional containing user identifier, or empty if not authenticated
+     */
+    Optional<String> getCurrentUserId();
+
+    /**
+     * Create a scoped job key that includes user ownership when security is enabled.
+     *
+     * @param jobId the base job identifier
+     * @return scoped job key in format "userId:jobId", or just jobId if no user authenticated
+     */
+    String createScopedJobKey(String jobId);
+
+    /**
+     * Validate that the current user has access to the given job.
+     *
+     * @param scopedJobKey the scoped job key to validate
+     * @return true if current user owns the job or no authentication is required
+     * @throws SecurityException if current user does not own the job
+     */
+    boolean validateJobAccess(String scopedJobKey);
+
+    /**
+     * Extract the base job ID from a scoped job key.
+     *
+     * @param scopedJobKey the scoped job key
+     * @return the base job ID without user prefix
+     */
+    String extractJobId(String scopedJobKey);
+}
@@ -0,0 +1,18 @@
+package stirling.software.common.util;
+
+/** Thread-local context for passing job ID across async boundaries */
+public class JobContext {
+    private static final ThreadLocal<String> CURRENT_JOB_ID = new ThreadLocal<>();
+
+    public static void setJobId(String jobId) {
+        CURRENT_JOB_ID.set(jobId);
+    }
+
+    public static String getJobId() {
+        return CURRENT_JOB_ID.get();
+    }
+
+    public static void clear() {
+        CURRENT_JOB_ID.remove();
+    }
+}
@@ -96,6 +96,7 @@ public class ProcessExecutor {
                                                .getProcessExecutor()
                                                .getSessionLimit()
                                                .getOcrMyPdfSessionLimit();
+                                case CFF_CONVERTER -> 1;
                            };

                    long timeoutMinutes =
@@ -150,6 +151,7 @@ public class ProcessExecutor {
                                                .getProcessExecutor()
                                                .getTimeoutMinutes()
                                                .getOcrMyPdfTimeoutMinutes();
+                                case CFF_CONVERTER -> 5L;
                            };
                    return new ProcessExecutor(semaphoreLimit, liveUpdates, timeoutMinutes);
                });
@@ -302,7 +304,8 @@ public class ProcessExecutor {
        TESSERACT,
        QPDF,
        GHOSTSCRIPT,
-        OCR_MY_PDF
+        OCR_MY_PDF,
+        CFF_CONVERTER
    }

    @Setter