kreuzberg 4.0.0.pre.rc.6

data/vendor/kreuzberg/src/panic_context.rs

@@ -0,0 +1,154 @@
+use std::any::Any;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+/// Context information captured when a panic occurs.
+///
+/// This struct stores detailed information about where and when a panic happened,
+/// enabling better error reporting across FFI boundaries.
+#[derive(Debug, Clone)]
+pub struct PanicContext {
+    /// Source file where the panic occurred
+    pub file: &'static str,
+    /// Line number where the panic occurred
+    pub line: u32,
+    /// Function name where the panic occurred
+    pub function: &'static str,
+    /// Panic message extracted from the panic payload
+    pub message: String,
+    /// Timestamp when the panic was captured
+    pub timestamp: SystemTime,
+}
+
+impl PanicContext {
+    /// Creates a new PanicContext with the given parameters.
+    ///
+    /// # Arguments
+    ///
+    /// * `file` - Source file path
+    /// * `line` - Line number
+    /// * `function` - Function name
+    /// * `panic_info` - The panic payload to extract message from
+    pub fn new(file: &'static str, line: u32, function: &'static str, panic_info: &dyn Any) -> Self {
+        let timestamp = std::panic::catch_unwind(SystemTime::now).unwrap_or(UNIX_EPOCH);
+
+        Self {
+            file,
+            line,
+            function,
+            message: extract_panic_message(panic_info),
+            timestamp,
+        }
+    }
+
+    /// Formats the panic context as a human-readable string.
+    pub fn format(&self) -> String {
+        format!(
+            "Panic at {}:{}:{} - {}",
+            self.file, self.line, self.function, self.message
+        )
+    }
+}
+
+/// Maximum panic message length to prevent DoS attacks
+const MAX_PANIC_MESSAGE_LEN: usize = 4096;
+
+/// Extracts a human-readable message from a panic payload.
+///
+/// Attempts to downcast the panic payload to common types (String, &str)
+/// to extract a meaningful error message.
+///
+/// Message is truncated to 4KB to prevent DoS attacks via extremely large panic messages.
+///
+/// # Arguments
+///
+/// * `panic_info` - The panic payload from catch_unwind
+///
+/// # Returns
+///
+/// A string representation of the panic message (truncated if necessary)
+pub fn extract_panic_message(panic_info: &dyn Any) -> String {
+    let msg = if let Some(s) = panic_info.downcast_ref::<String>() {
+        s.clone()
+    } else if let Some(s) = panic_info.downcast_ref::<&str>() {
+        (*s).to_string()
+    } else {
+        "Unknown panic payload".to_string()
+    };
+
+    if msg.len() > MAX_PANIC_MESSAGE_LEN {
+        let truncate_at = msg.floor_char_boundary(MAX_PANIC_MESSAGE_LEN);
+        format!("{}... [truncated]", &msg[..truncate_at])
+    } else {
+        msg
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_extract_panic_message_string() {
+        let panic_msg = "test panic".to_string();
+        let msg = extract_panic_message(&panic_msg);
+        assert_eq!(msg, "test panic");
+    }
+
+    #[test]
+    fn test_extract_panic_message_str() {
+        let panic_msg: &str = "test panic";
+        let msg = extract_panic_message(&panic_msg);
+        assert_eq!(msg, "test panic");
+    }
+
+    #[test]
+    fn test_extract_panic_message_unknown() {
+        let panic_msg = 42i32;
+        let msg = extract_panic_message(&panic_msg);
+        assert_eq!(msg, "Unknown panic payload");
+    }
+
+    #[test]
+    fn test_panic_context_format() {
+        let panic_msg = "test error".to_string();
+        let ctx = PanicContext::new("test.rs", 42, "test_function", &panic_msg);
+
+        let formatted = ctx.format();
+        assert!(formatted.contains("test.rs"));
+        assert!(formatted.contains("42"));
+        assert!(formatted.contains("test_function"));
+        assert!(formatted.contains("test error"));
+    }
+
+    #[test]
+    fn test_panic_message_truncation() {
+        let long_msg = "x".repeat(5000);
+        let msg = extract_panic_message(&long_msg);
+        assert!(msg.len() <= MAX_PANIC_MESSAGE_LEN + 20);
+        assert!(msg.ends_with("... [truncated]"));
+    }
+
+    #[test]
+    fn test_panic_message_truncation_utf8_boundary() {
+        let mut msg = "x".repeat(4093);
+        msg.push('🦀');
+        msg.push_str("yyy");
+
+        let truncated = extract_panic_message(&msg);
+
+        assert!(truncated.ends_with("... [truncated]"));
+
+        assert!(std::str::from_utf8(truncated.as_bytes()).is_ok());
+
+        assert!(!truncated.contains("🦀"));
+        assert!(!truncated.contains("yyy"));
+    }
+
+    #[test]
+    fn test_panic_message_no_truncation_needed() {
+        let short_msg = "short".to_string();
+        let msg = extract_panic_message(&short_msg);
+        assert_eq!(msg, "short");
+        assert!(!msg.contains("[truncated]"));
+    }
+}

data/vendor/kreuzberg/src/pdf/error.rs

@@ -0,0 +1,122 @@
+use std::fmt;
+
+#[derive(Debug, Clone)]
+pub enum PdfError {
+    InvalidPdf(String),
+    PasswordRequired,
+    InvalidPassword,
+    EncryptionNotSupported(String),
+    PageNotFound(usize),
+    TextExtractionFailed(String),
+    RenderingFailed(String),
+    MetadataExtractionFailed(String),
+    IOError(String),
+}
+
+impl fmt::Display for PdfError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            PdfError::InvalidPdf(msg) => write!(f, "Invalid PDF: {}", msg),
+            PdfError::PasswordRequired => write!(f, "PDF is password-protected"),
+            PdfError::InvalidPassword => write!(f, "Invalid password provided"),
+            PdfError::EncryptionNotSupported(msg) => {
+                write!(f, "Encryption not supported: {}", msg)
+            }
+            PdfError::PageNotFound(page) => write!(f, "Page {} not found", page),
+            PdfError::TextExtractionFailed(msg) => write!(f, "Text extraction failed: {}", msg),
+            PdfError::RenderingFailed(msg) => write!(f, "Page rendering failed: {}", msg),
+            PdfError::MetadataExtractionFailed(msg) => {
+                write!(f, "Metadata extraction failed: {}", msg)
+            }
+            PdfError::IOError(msg) => write!(f, "I/O error: {}", msg),
+        }
+    }
+}
+
+impl std::error::Error for PdfError {}
+
+// NOTE: No From<std::io::Error> impl - IO errors must bubble up unchanged per error handling policy
+
+impl From<lopdf::Error> for PdfError {
+    fn from(err: lopdf::Error) -> Self {
+        match err {
+            lopdf::Error::IO(io_err) => PdfError::IOError(io_err.to_string()),
+            _ => PdfError::InvalidPdf(err.to_string()),
+        }
+    }
+}
+
+pub type Result<T> = std::result::Result<T, PdfError>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_invalid_pdf_error() {
+        let err = PdfError::InvalidPdf("corrupted header".to_string());
+        assert_eq!(err.to_string(), "Invalid PDF: corrupted header");
+    }
+
+    #[test]
+    fn test_password_required_error() {
+        let err = PdfError::PasswordRequired;
+        assert_eq!(err.to_string(), "PDF is password-protected");
+    }
+
+    #[test]
+    fn test_invalid_password_error() {
+        let err = PdfError::InvalidPassword;
+        assert_eq!(err.to_string(), "Invalid password provided");
+    }
+
+    #[test]
+    fn test_encryption_not_supported_error() {
+        let err = PdfError::EncryptionNotSupported("AES-256".to_string());
+        assert_eq!(err.to_string(), "Encryption not supported: AES-256");
+    }
+
+    #[test]
+    fn test_page_not_found_error() {
+        let err = PdfError::PageNotFound(5);
+        assert_eq!(err.to_string(), "Page 5 not found");
+    }
+
+    #[test]
+    fn test_text_extraction_failed_error() {
+        let err = PdfError::TextExtractionFailed("no text layer".to_string());
+        assert_eq!(err.to_string(), "Text extraction failed: no text layer");
+    }
+
+    #[test]
+    fn test_rendering_failed_error() {
+        let err = PdfError::RenderingFailed("out of memory".to_string());
+        assert_eq!(err.to_string(), "Page rendering failed: out of memory");
+    }
+
+    #[test]
+    fn test_metadata_extraction_failed_error() {
+        let err = PdfError::MetadataExtractionFailed("invalid metadata".to_string());
+        assert_eq!(err.to_string(), "Metadata extraction failed: invalid metadata");
+    }
+
+    #[test]
+    fn test_io_error() {
+        let err = PdfError::IOError("read failed".to_string());
+        assert_eq!(err.to_string(), "I/O error: read failed");
+    }
+
+    #[test]
+    fn test_error_debug() {
+        let err = PdfError::InvalidPassword;
+        let debug_str = format!("{:?}", err);
+        assert!(debug_str.contains("InvalidPassword"));
+    }
+
+    #[test]
+    fn test_error_clone() {
+        let err1 = PdfError::PageNotFound(3);
+        let err2 = err1.clone();
+        assert_eq!(err1.to_string(), err2.to_string());
+    }
+}

data/vendor/kreuzberg/src/pdf/images.rs

@@ -0,0 +1,139 @@
+use super::error::{PdfError, Result};
+use lopdf::Document;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PdfImage {
+    pub page_number: usize,
+    pub image_index: usize,
+    pub width: i64,
+    pub height: i64,
+    pub color_space: Option<String>,
+    pub bits_per_component: Option<i64>,
+    pub filters: Vec<String>,
+    pub data: Vec<u8>,
+}
+
+#[derive(Debug)]
+pub struct PdfImageExtractor {
+    document: Document,
+}
+
+impl PdfImageExtractor {
+    pub fn new(pdf_bytes: &[u8]) -> Result<Self> {
+        Self::new_with_password(pdf_bytes, None)
+    }
+
+    pub fn new_with_password(pdf_bytes: &[u8], password: Option<&str>) -> Result<Self> {
+        let mut doc =
+            Document::load_mem(pdf_bytes).map_err(|e| PdfError::InvalidPdf(format!("Failed to load PDF: {}", e)))?;
+
+        if doc.is_encrypted() {
+            if let Some(pwd) = password {
+                doc.decrypt(pwd).map_err(|_| PdfError::InvalidPassword)?;
+            } else {
+                return Err(PdfError::PasswordRequired);
+            }
+        }
+
+        Ok(Self { document: doc })
+    }
+
+    pub fn extract_images(&self) -> Result<Vec<PdfImage>> {
+        let mut all_images = Vec::new();
+        let pages = self.document.get_pages();
+
+        for (page_num, page_id) in pages.iter() {
+            let images = self
+                .document
+                .get_page_images(*page_id)
+                .map_err(|e| PdfError::MetadataExtractionFailed(format!("Failed to get page images: {}", e)))?;
+
+            for (img_index, img) in images.iter().enumerate() {
+                let filters = img.filters.clone().unwrap_or_default();
+
+                all_images.push(PdfImage {
+                    page_number: *page_num as usize,
+                    image_index: img_index + 1,
+                    width: img.width,
+                    height: img.height,
+                    color_space: img.color_space.clone(),
+                    bits_per_component: img.bits_per_component,
+                    filters,
+                    data: img.content.to_vec(),
+                });
+            }
+        }
+
+        Ok(all_images)
+    }
+
+    pub fn extract_images_from_page(&self, page_number: u32) -> Result<Vec<PdfImage>> {
+        let pages = self.document.get_pages();
+        let page_id = pages
+            .get(&page_number)
+            .ok_or(PdfError::PageNotFound(page_number as usize))?;
+
+        let images = self
+            .document
+            .get_page_images(*page_id)
+            .map_err(|e| PdfError::MetadataExtractionFailed(format!("Failed to get page images: {}", e)))?;
+
+        let mut page_images = Vec::new();
+        for (img_index, img) in images.iter().enumerate() {
+            let filters = img.filters.clone().unwrap_or_default();
+
+            page_images.push(PdfImage {
+                page_number: page_number as usize,
+                image_index: img_index + 1,
+                width: img.width,
+                height: img.height,
+                color_space: img.color_space.clone(),
+                bits_per_component: img.bits_per_component,
+                filters,
+                data: img.content.to_vec(),
+            });
+        }
+
+        Ok(page_images)
+    }
+
+    pub fn get_image_count(&self) -> Result<usize> {
+        let images = self.extract_images()?;
+        Ok(images.len())
+    }
+}
+
+pub fn extract_images_from_pdf(pdf_bytes: &[u8]) -> Result<Vec<PdfImage>> {
+    let extractor = PdfImageExtractor::new(pdf_bytes)?;
+    extractor.extract_images()
+}
+
+pub fn extract_images_from_pdf_with_password(pdf_bytes: &[u8], password: &str) -> Result<Vec<PdfImage>> {
+    let extractor = PdfImageExtractor::new_with_password(pdf_bytes, Some(password))?;
+    extractor.extract_images()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_extractor_creation() {
+        let result = PdfImageExtractor::new(b"not a pdf");
+        assert!(result.is_err());
+        assert!(matches!(result.unwrap_err(), PdfError::InvalidPdf(_)));
+    }
+
+    #[test]
+    fn test_extract_images_invalid_pdf() {
+        let result = extract_images_from_pdf(b"not a pdf");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_extract_images_empty_pdf() {
+        let result = extract_images_from_pdf(b"");
+        assert!(result.is_err());
+    }
+}