Skip to main content

brows3_lib/commands/
objects.rs

1use crate::commands::profiles::ProfileState;
2use crate::error::Result;
3use crate::s3::{FolderContent, S3Object, S3State};
4use aws_sdk_s3::Client;
5use serde::{Deserialize, Serialize};
6use std::collections::HashSet;
7use tauri::State;
8
9const MAX_SORTABLE_FOLDER_ITEMS: usize = 100_000;
10const MAX_COMPLETE_LIST_REQUESTS: usize = 100;
11const MAX_SEARCH_SCANNED_OBJECTS: u64 = 100_000;
12const MAX_SEARCH_RESULTS: usize = 10_000;
13const MAX_SEARCH_REQUESTS: usize = 100;
14const DEFAULT_MAX_TEXT_PREVIEW_BYTES: u64 = 2 * 1024 * 1024;
15const MAX_TEXT_PREVIEW_BYTES: u64 = 100 * 1024 * 1024;
16
17fn normalized_text_preview_limit(max_bytes: Option<u64>) -> u64 {
18    max_bytes
19        .unwrap_or(DEFAULT_MAX_TEXT_PREVIEW_BYTES)
20        .clamp(1, MAX_TEXT_PREVIEW_BYTES)
21}
22
23fn text_preview_size_error(actual_bytes: Option<u64>, max_bytes: u64) -> crate::error::AppError {
24    let limit_mb = max_bytes as f64 / 1024.0 / 1024.0;
25    let message = if let Some(actual_bytes) = actual_bytes {
26        format!(
27            "Object is too large to preview as text ({:.2} MB; configured limit {:.0} MB). Increase the text preview limit in Settings or download it.",
28            actual_bytes as f64 / 1024.0 / 1024.0,
29            limit_mb
30        )
31    } else {
32        format!(
33            "Object exceeds the configured text preview limit of {:.0} MB. Increase the limit in Settings or download it.",
34            limit_mb
35        )
36    };
37
38    crate::error::AppError::InvalidContent(message)
39}
40
41fn preview_chunk_fits(current_bytes: usize, chunk_bytes: usize, max_bytes: u64) -> bool {
42    (chunk_bytes as u64) <= max_bytes.saturating_sub(current_bytes as u64)
43}
44
45fn is_likely_binary_text_mismatch(bytes: &[u8]) -> bool {
46    if bytes.is_empty() {
47        return false;
48    }
49
50    let mut control_count = 0usize;
51    for &byte in bytes {
52        if byte == 0 {
53            return true;
54        }
55
56        if byte < 0x20 && !matches!(byte, b'\n' | b'\r' | b'\t' | 0x0c) {
57            control_count += 1;
58        }
59    }
60
61    control_count.saturating_mul(100) > bytes.len().saturating_mul(5)
62}
63
64#[derive(Debug, Serialize, Deserialize)]
65pub struct ListObjectsResult {
66    pub objects: Vec<S3Object>,
67    pub common_prefixes: Vec<String>,
68    pub next_continuation_token: Option<String>,
69    pub is_truncated: bool,
70    pub prefix: String,
71    pub bucket_region: Option<String>,
72}
73
74#[derive(Debug, Serialize, Deserialize)]
75pub struct SearchObjectsResult {
76    pub objects: Vec<S3Object>,
77    pub scanned_objects: u64,
78    pub is_truncated: bool,
79}
80
81fn normalize_sort_field(sort_field: Option<String>) -> Option<String> {
82    match sort_field.as_deref() {
83        Some("name") | Some("size") | Some("date") | Some("class") => sort_field,
84        _ => None,
85    }
86}
87
88fn normalize_sort_direction(sort_direction: Option<String>) -> String {
89    match sort_direction.as_deref() {
90        Some("desc") => "desc".to_string(),
91        _ => "asc".to_string(),
92    }
93}
94
95fn paginate_folder_content(
96    content: &FolderContent,
97    prefix: String,
98    bucket_region: Option<String>,
99    continuation_token: Option<String>,
100    max_keys: Option<i32>,
101) -> Result<ListObjectsResult> {
102    let expired = || {
103        crate::error::AppError::ConfigError(
104            "This listing has changed. Refresh the folder to continue.".to_string(),
105        )
106    };
107    let offset = match continuation_token {
108        Some(token) => {
109            let (generation, offset) = token.split_once(':').ok_or_else(expired)?;
110            if generation != content.generation {
111                return Err(expired());
112            }
113            offset.parse::<usize>().map_err(|_| expired())?
114        }
115        None => 0,
116    };
117    if offset > content.objects.len() {
118        return Err(expired());
119    }
120    let max = max_keys.unwrap_or(1000).max(1) as usize;
121    let end = offset.saturating_add(max).min(content.objects.len());
122    let next_token = if end < content.objects.len() {
123        Some(format!("{}:{end}", content.generation))
124    } else {
125        None
126    };
127
128    Ok(ListObjectsResult {
129        objects: content.objects[offset..end].to_vec(),
130        common_prefixes: if offset == 0 {
131            content.common_prefixes.clone()
132        } else {
133            Vec::new()
134        },
135        next_continuation_token: next_token.clone(),
136        is_truncated: next_token.is_some(),
137        prefix,
138        bucket_region,
139    })
140}
141
142async fn list_complete_folder_content(
143    client: &Client,
144    bucket_name: &str,
145    prefix: &str,
146    delimiter: &str,
147) -> Result<FolderContent> {
148    let mut objects = Vec::new();
149    let mut common_prefixes = Vec::new();
150    let mut seen_prefixes = HashSet::new();
151    let mut continuation_token: Option<String> = None;
152    let mut request_count = 0usize;
153
154    loop {
155        if request_count >= MAX_COMPLETE_LIST_REQUESTS {
156            return Err(crate::error::AppError::ConfigError(format!(
157                "This folder requires more than {} S3 LIST requests for complete-result sorting. Use name ascending or narrow the prefix.",
158                MAX_COMPLETE_LIST_REQUESTS
159            )));
160        }
161
162        let mut request = client
163            .list_objects_v2()
164            .bucket(bucket_name)
165            .prefix(prefix)
166            .max_keys(1000);
167
168        if !delimiter.is_empty() {
169            request = request.delimiter(delimiter);
170        }
171
172        if let Some(token) = &continuation_token {
173            request = request.continuation_token(token);
174        }
175
176        let output = request
177            .send()
178            .await
179            .map_err(|err| crate::error::AppError::S3Error(err.to_string()))?;
180        request_count += 1;
181
182        for obj in output.contents() {
183            let key = obj.key().unwrap_or_default();
184            let size = obj.size().unwrap_or(0);
185            if !delimiter.is_empty() && key.ends_with('/') && size == 0 {
186                continue;
187            }
188
189            objects.push(S3Object {
190                key: key.to_string(),
191                last_modified: obj.last_modified().map(|d| d.to_string()),
192                size,
193                storage_class: obj.storage_class().map(|s| s.as_str().to_string()),
194            });
195        }
196
197        for common_prefix in output.common_prefixes() {
198            let prefix = common_prefix.prefix().unwrap_or_default().to_string();
199            if seen_prefixes.insert(prefix.clone()) {
200                common_prefixes.push(prefix);
201            }
202        }
203
204        if objects.len().saturating_add(common_prefixes.len()) > MAX_SORTABLE_FOLDER_ITEMS {
205            return Err(crate::error::AppError::ConfigError(format!(
206                "This folder exceeds the {}-item safety limit for complete-result sorting. Use name ascending or narrow the prefix.",
207                MAX_SORTABLE_FOLDER_ITEMS
208            )));
209        }
210
211        if output.is_truncated().unwrap_or(false) {
212            continuation_token = Some(
213                output
214                    .next_continuation_token()
215                    .ok_or_else(|| {
216                        crate::error::AppError::S3Error(
217                            "S3 returned a truncated sorted listing without a continuation token"
218                                .to_string(),
219                        )
220                    })?
221                    .to_string(),
222            );
223        } else {
224            break;
225        }
226    }
227
228    Ok(FolderContent {
229        generation: uuid::Uuid::new_v4().to_string(),
230        objects,
231        common_prefixes,
232    })
233}
234
235fn sort_folder_content(content: &mut FolderContent, sort_field: &str, sort_direction: &str) {
236    content.common_prefixes.sort();
237    if sort_direction == "desc" {
238        content.common_prefixes.reverse();
239    }
240
241    content.objects.sort_by(|a, b| {
242        let ordering = match sort_field {
243            "size" => a.size.cmp(&b.size).then_with(|| a.key.cmp(&b.key)),
244            "date" => a
245                .last_modified
246                .cmp(&b.last_modified)
247                .then_with(|| a.key.cmp(&b.key)),
248            "class" => a
249                .storage_class
250                .cmp(&b.storage_class)
251                .then_with(|| a.key.cmp(&b.key)),
252            _ => a.key.cmp(&b.key),
253        };
254
255        if sort_direction == "desc" {
256            ordering.reverse()
257        } else {
258            ordering
259        }
260    });
261}
262
263#[allow(clippy::too_many_arguments)]
264#[tauri::command]
265pub async fn list_objects(
266    bucket_name: String,
267    bucket_region: Option<String>,
268    prefix: Option<String>,
269    delimiter: Option<String>,
270    continuation_token: Option<String>,
271    max_keys: Option<i32>,
272    bypass_cache: Option<bool>,
273    sort_field: Option<String>,
274    sort_direction: Option<String>,
275    expected_profile_id: String,
276    profile_state: State<'_, ProfileState>,
277    s3_state: State<'_, S3State>,
278) -> Result<ListObjectsResult> {
279    let prefix_str = prefix.clone().unwrap_or_default();
280    let delimiter_str = delimiter.unwrap_or_else(|| "/".to_string());
281    let requested_bucket_region = bucket_region.clone();
282    let sort_field = normalize_sort_field(sort_field);
283    let sort_direction = normalize_sort_direction(sort_direction);
284    let uses_complete_sort = sort_field
285        .as_deref()
286        .map(|field| field != "name" || sort_direction == "desc")
287        .unwrap_or(false)
288        && !delimiter_str.is_empty();
289
290    // Get active profile
291    let profile_manager = profile_state.read().await;
292    let active_profile = profile_manager
293        .get_active_profile()
294        .await?
295        .ok_or_else(|| crate::error::AppError::ProfileNotFound("No active profile".into()))?;
296    drop(profile_manager);
297    super::operations::validate_operation_profile(Some(&expected_profile_id), &active_profile.id)?;
298
299    // 1. Try Read Lock first for Cache (highly concurrent)
300    {
301        let s3_manager = s3_state.read().await;
302        let cached_bucket_region = s3_manager
303            .get_bucket_region(&active_profile, &bucket_name)
304            .or(requested_bucket_region.clone());
305        if uses_complete_sort && !bypass_cache.unwrap_or(false) {
306            if let Some(field) = sort_field.as_deref() {
307                if let Some(content) = s3_manager.get_sorted_folder_content(
308                    &active_profile.cache_identity(),
309                    &bucket_name,
310                    &prefix_str,
311                    field,
312                    &sort_direction,
313                ) {
314                    return paginate_folder_content(
315                        content,
316                        prefix_str,
317                        cached_bucket_region,
318                        continuation_token,
319                        max_keys,
320                    );
321                }
322            }
323        }
324    }
325
326    if uses_complete_sort && continuation_token.is_some() {
327        return Err(crate::error::AppError::ConfigError(
328            "This listing has expired. Refresh the folder to continue.".to_string(),
329        ));
330    }
331
332    // If bypassing cache, we should invalidate the existing cache for this bucket
333    if bypass_cache.unwrap_or(false) {
334        let mut s3_manager = s3_state.write().await;
335        s3_manager.remove_bucket_cache(&active_profile.id, &bucket_name);
336    }
337
338    // Check cache for bucket region first
339    let mut resolved_bucket_region = {
340        let s3_manager = s3_state.read().await;
341        s3_manager.get_bucket_region(&active_profile, &bucket_name)
342    }
343    .or(bucket_region);
344
345    let client = {
346        let mut s3_manager = s3_state.write().await;
347        if let Some(ref region) = resolved_bucket_region {
348            s3_manager
349                .get_client_for_region(&active_profile, region)
350                .await?
351                .clone()
352        } else {
353            s3_manager.get_client(&active_profile).await?.clone()
354        }
355    };
356
357    if uses_complete_sort {
358        let field = sort_field.clone().unwrap_or_else(|| "name".to_string());
359        let mut content =
360            match list_complete_folder_content(&client, &bucket_name, &prefix_str, &delimiter_str)
361                .await
362            {
363                Ok(content) => content,
364                Err(err) => {
365                    if matches!(&err, crate::error::AppError::ConfigError(_)) {
366                        return Err(err);
367                    }
368
369                    log::warn!(
370                        "Sorted list_objects failed, attempting region discovery: {}",
371                        err
372                    );
373                    let detected_region = {
374                        let retry_client = {
375                            let mut s3_manager = s3_state.write().await;
376                            s3_manager.get_client(&active_profile).await?.clone()
377                        };
378                        crate::s3::get_bucket_region(&retry_client, &bucket_name)
379                            .await
380                            .ok()
381                    };
382
383                    if let Some(new_region) = detected_region {
384                        let new_client = {
385                            let mut s3_manager = s3_state.write().await;
386                            s3_manager.set_bucket_region(
387                                &active_profile,
388                                &bucket_name,
389                                new_region.clone(),
390                            );
391                            s3_manager
392                                .get_client_for_region(&active_profile, &new_region)
393                                .await?
394                                .clone()
395                        };
396                        resolved_bucket_region = Some(new_region);
397                        list_complete_folder_content(
398                            &new_client,
399                            &bucket_name,
400                            &prefix_str,
401                            &delimiter_str,
402                        )
403                        .await?
404                    } else {
405                        return Err(err);
406                    }
407                }
408            };
409
410        sort_folder_content(&mut content, &field, &sort_direction);
411
412        {
413            let mut s3_manager = s3_state.write().await;
414            s3_manager.set_sorted_folder_content(
415                &active_profile.cache_identity(),
416                &bucket_name,
417                &prefix_str,
418                &field,
419                &sort_direction,
420                content.clone(),
421            );
422        }
423
424        return paginate_folder_content(
425            &content,
426            prefix_str,
427            resolved_bucket_region.or(requested_bucket_region),
428            continuation_token,
429            max_keys,
430        );
431    }
432
433    // 3. Perform network IO outside of locks, including retry logic
434    let mut request = client
435        .list_objects_v2()
436        .bucket(&bucket_name)
437        .prefix(&prefix_str);
438
439    // Only set delimiter if it's non-empty - empty/omitted delimiter returns ALL nested objects (recursive)
440    if !delimiter_str.is_empty() {
441        request = request.delimiter(&delimiter_str);
442    }
443
444    if let Some(token) = &continuation_token {
445        request = request.continuation_token(token);
446    }
447    if let Some(max) = max_keys {
448        request = request.max_keys(max);
449    }
450
451    let result = request.send().await;
452
453    // Handle the result, implementing retry logic on error
454    let output = match result {
455        Ok(out) => out,
456        Err(err) => {
457            log::warn!("Initial list_objects failed: {}", err);
458            // Attempt to detect region and retry
459            let detected_region = {
460                // ... (Region detection logic remains the same, we trust get_bucket_region works on any client usually)
461                let retry_client = {
462                    let s3_manager = s3_state.read().await;
463                    // Use default region client to ask about location
464                    // We don't need write lock just to get a client that might already exist
465                    // Wait, get_client requires &mut Self. Okay, we need write lock.
466                    drop(s3_manager);
467                    let mut s3_manager = s3_state.write().await;
468                    s3_manager.get_client(&active_profile).await?.clone()
469                };
470
471                match crate::s3::get_bucket_region(&retry_client, &bucket_name).await {
472                    Ok(region) => {
473                        log::info!(
474                            "Detected correct region for bucket '{}': {}",
475                            bucket_name,
476                            region
477                        );
478                        Some(region)
479                    }
480                    Err(e) => {
481                        log::error!("Failed to detect bucket region: {}", e);
482                        None
483                    }
484                }
485            };
486
487            if let Some(new_region) = detected_region {
488                // Get NEW client for this region
489                let new_client = {
490                    let mut s3_manager = s3_state.write().await;
491                    s3_manager
492                        .get_client_for_region(&active_profile, &new_region)
493                        .await?
494                        .clone()
495                };
496
497                // Retry request
498                let mut retry_req = new_client
499                    .list_objects_v2()
500                    .bucket(&bucket_name)
501                    .prefix(&prefix_str);
502
503                // Only set delimiter if it's non-empty
504                if !delimiter_str.is_empty() {
505                    retry_req = retry_req.delimiter(&delimiter_str);
506                }
507
508                if let Some(token) = &continuation_token {
509                    retry_req = retry_req.continuation_token(token);
510                }
511                if let Some(max) = max_keys {
512                    retry_req = retry_req.max_keys(max);
513                }
514
515                // Update the region we will return and use for fallback
516                resolved_bucket_region = Some(new_region.clone());
517
518                // Cache the discovered region for future requests
519                {
520                    let mut s3_manager = s3_state.write().await;
521                    s3_manager.set_bucket_region(&active_profile, &bucket_name, new_region);
522                }
523
524                retry_req
525                    .send()
526                    .await
527                    .map_err(|e| crate::error::AppError::S3Error(format!("Retry failed: {}", e)))?
528            } else {
529                return Err(crate::error::AppError::S3Error(err.to_string()));
530            }
531        }
532    };
533
534    // Map objects, filtering out folder markers (zero-byte objects ending with /)
535    let mut objects: Vec<S3Object> = output
536        .contents()
537        .iter()
538        .filter(|obj| {
539            let key = obj.key().unwrap_or_default();
540            let size = obj.size().unwrap_or(0);
541
542            // Exclude folder markers (zero-byte objects ending with '/') ONLY if we are using a delimiter (structured view).
543            // In recursive view (no delimiter), we want ALL markers so they can be managed/deleted.
544            if !delimiter_str.is_empty() && key.ends_with('/') && size == 0 {
545                return false;
546            }
547            true
548        })
549        .map(|obj| S3Object {
550            key: obj.key().unwrap_or_default().to_string(),
551            last_modified: obj.last_modified().map(|d| d.to_string()),
552            size: obj.size().unwrap_or(0),
553            storage_class: obj.storage_class().map(|s| s.as_str().to_string()),
554        })
555        .collect();
556
557    // Map common prefixes (folders)
558    let common_prefixes: Vec<String> = output
559        .common_prefixes()
560        .iter()
561        .map(|cp| cp.prefix().unwrap_or_default().to_string())
562        .collect();
563
564    // Fallback: If empty, try HeadObject to see if it's a direct file reference
565    // We strip the trailing slash because some systems/users append it accidentally to files
566    if objects.is_empty()
567        && common_prefixes.is_empty()
568        && !prefix_str.is_empty()
569        && !prefix_str.ends_with('/')
570    {
571        let clean_key = prefix_str.trim_end_matches('/').to_string();
572        if !clean_key.is_empty() {
573            let client = {
574                let mut s3_manager = s3_state.write().await;
575                if let Some(ref region) = resolved_bucket_region {
576                    s3_manager
577                        .get_client_for_region(&active_profile, region)
578                        .await?
579                        .clone()
580                } else {
581                    s3_manager.get_client(&active_profile).await?.clone()
582                }
583            };
584
585            if let Ok(head_output) = client
586                .head_object()
587                .bucket(&bucket_name)
588                .key(&clean_key)
589                .send()
590                .await
591            {
592                objects.push(S3Object {
593                    key: clean_key,
594                    last_modified: head_output.last_modified().map(|d| d.to_string()),
595                    size: head_output.content_length().unwrap_or(0),
596                    storage_class: head_output.storage_class().map(|s| s.as_str().to_string()),
597                });
598            }
599        }
600    }
601
602    Ok(ListObjectsResult {
603        objects,
604        common_prefixes,
605        next_continuation_token: output.next_continuation_token().map(|s| s.to_string()),
606        is_truncated: output.is_truncated().unwrap_or(false),
607        prefix: prefix_str,
608        bucket_region: resolved_bucket_region.or(requested_bucket_region),
609    })
610}
611
612#[tauri::command]
613pub async fn search_objects(
614    bucket_name: String,
615    bucket_region: Option<String>,
616    prefix: Option<String>,
617    query: String,
618    expected_profile_id: String,
619    profile_state: State<'_, ProfileState>,
620    s3_state: State<'_, S3State>,
621) -> Result<SearchObjectsResult> {
622    let profile_manager = profile_state.read().await;
623    let active_profile = profile_manager
624        .get_active_profile()
625        .await?
626        .ok_or_else(|| crate::error::AppError::ProfileNotFound("No active profile".into()))?;
627    drop(profile_manager);
628    super::operations::validate_operation_profile(Some(&expected_profile_id), &active_profile.id)?;
629
630    let prefix_str = prefix.unwrap_or_default();
631    let query_lower = query.to_lowercase();
632
633    // Check cache for bucket region first
634    let bucket_region = {
635        let s3_manager = s3_state.read().await;
636        s3_manager.get_bucket_region(&active_profile, &bucket_name)
637    }
638    .or(bucket_region);
639
640    let mut client = {
641        let mut s3_manager = s3_state.write().await;
642        if let Some(ref region) = bucket_region {
643            s3_manager
644                .get_client_for_region(&active_profile, region)
645                .await?
646                .clone()
647        } else {
648            s3_manager.get_client(&active_profile).await?.clone()
649        }
650    };
651
652    let mut objects = Vec::new();
653    let mut continuation_token = None;
654    let mut calls = 0;
655    let mut scanned_objects = 0u64;
656    let mut is_truncated = false;
657
658    loop {
659        let mut req = client
660            .list_objects_v2()
661            .bucket(&bucket_name)
662            .prefix(&prefix_str)
663            .max_keys(1000); // Respect prefix context
664
665        if let Some(ref token) = continuation_token {
666            req = req.continuation_token(token);
667        }
668
669        let result = req.send().await;
670
671        // implement region detection and retry on error
672        let output = match result {
673            Ok(out) => out,
674            Err(err) => {
675                log::warn!("Search list_objects failed: {}", err);
676                if calls > 0 {
677                    return Err(crate::error::AppError::S3Error(format!(
678                        "Search failed after reading {} S3 pages: {}",
679                        calls, err
680                    )));
681                }
682
683                // Attempt to detect region and retry (only if this is the first call)
684                let detected_region = {
685                    let retry_client = {
686                        let mut s3_manager = s3_state.write().await;
687                        s3_manager.get_client(&active_profile).await?.clone()
688                    };
689                    crate::s3::get_bucket_region(&retry_client, &bucket_name)
690                        .await
691                        .ok()
692                };
693
694                if let Some(new_region) = detected_region {
695                    let new_client = {
696                        let mut s3_manager = s3_state.write().await;
697                        s3_manager.set_bucket_region(
698                            &active_profile,
699                            &bucket_name,
700                            new_region.clone(),
701                        );
702                        s3_manager
703                            .get_client_for_region(&active_profile, &new_region)
704                            .await?
705                            .clone()
706                    };
707                    client = new_client.clone();
708
709                    let mut retry_req = new_client
710                        .list_objects_v2()
711                        .bucket(&bucket_name)
712                        .prefix(&prefix_str)
713                        .max_keys(1000);
714
715                    if let Some(token) = &continuation_token {
716                        retry_req = retry_req.continuation_token(token);
717                    }
718
719                    retry_req.send().await.map_err(|e| {
720                        crate::error::AppError::S3Error(format!("Search retry failed: {}", e))
721                    })?
722                } else {
723                    return Err(crate::error::AppError::S3Error(err.to_string()));
724                }
725            }
726        };
727
728        calls += 1;
729
730        for obj in output.contents() {
731            if scanned_objects >= MAX_SEARCH_SCANNED_OBJECTS {
732                is_truncated = true;
733                break;
734            }
735            scanned_objects += 1;
736
737            let key = obj.key().unwrap_or_default();
738            let size = obj.size().unwrap_or(0);
739            // Skip folder markers (zero-byte objects ending with /)
740            if key.ends_with('/') && size == 0 {
741                continue;
742            }
743            if key.to_lowercase().contains(&query_lower) {
744                objects.push(S3Object {
745                    key: key.to_string(),
746                    size,
747                    last_modified: obj.last_modified().map(|d| d.to_string()),
748                    storage_class: obj.storage_class().map(|s| s.as_str().to_string()),
749                });
750
751                if objects.len() >= MAX_SEARCH_RESULTS {
752                    is_truncated = true;
753                    break;
754                }
755            }
756        }
757
758        if output.is_truncated().unwrap_or(false) && calls >= MAX_SEARCH_REQUESTS {
759            is_truncated = true;
760        }
761
762        if is_truncated {
763            log::warn!(
764                "Deep search in bucket '{}' stopped at safety limits ({} scanned, {} results)",
765                bucket_name,
766                scanned_objects,
767                objects.len()
768            );
769            break;
770        }
771
772        if !output.is_truncated().unwrap_or(false) {
773            break;
774        }
775        continuation_token = Some(
776            output
777                .next_continuation_token()
778                .ok_or_else(|| {
779                    crate::error::AppError::S3Error(
780                        "S3 returned a truncated search listing without a continuation token"
781                            .to_string(),
782                    )
783                })?
784                .to_string(),
785        );
786    }
787
788    Ok(SearchObjectsResult {
789        objects,
790        scanned_objects,
791        is_truncated,
792    })
793}
794
795#[tauri::command]
796pub async fn get_presigned_url(
797    bucket_name: String,
798    bucket_region: Option<String>,
799    key: String,
800    expires_in: u64,
801    expected_profile_id: String,
802    profile_state: State<'_, ProfileState>,
803    s3_state: State<'_, S3State>,
804) -> Result<String> {
805    use aws_sdk_s3::presigning::PresigningConfig;
806    use std::time::Duration;
807
808    let profile_manager = profile_state.read().await;
809    let active_profile = profile_manager
810        .get_active_profile()
811        .await?
812        .ok_or_else(|| crate::error::AppError::ProfileNotFound("No active profile".into()))?;
813    drop(profile_manager);
814    super::operations::validate_operation_profile(Some(&expected_profile_id), &active_profile.id)?;
815
816    let bucket_region = {
817        let s3_manager = s3_state.read().await;
818        s3_manager.get_bucket_region(&active_profile, &bucket_name)
819    }
820    .or(bucket_region);
821
822    let client = {
823        let mut s3_manager = s3_state.write().await;
824        if let Some(ref region) = bucket_region {
825            s3_manager
826                .get_client_for_region(&active_profile, region)
827                .await?
828                .clone()
829        } else {
830            s3_manager.get_client(&active_profile).await?.clone()
831        }
832    };
833
834    let presigning_config_result = PresigningConfig::expires_in(Duration::from_secs(expires_in))
835        .map_err(|e| crate::error::AppError::S3Error(e.to_string()));
836
837    let mut get_obj_builder = client
838        .get_object()
839        .bucket(&bucket_name)
840        .key(&key)
841        .response_content_disposition("inline");
842
843    // Force PDF content type if extension matches, ensuring browser renders it
844    if key.to_lowercase().ends_with(".pdf") {
845        get_obj_builder = get_obj_builder.response_content_type("application/pdf");
846    }
847
848    let presigned_request_result = match presigning_config_result {
849        Ok(config) => get_obj_builder
850            .presigned(config)
851            .await
852            .map_err(|e| crate::error::AppError::S3Error(e.to_string())),
853        Err(e) => Err(e),
854    };
855
856    match presigned_request_result {
857        Ok(req) => Ok(req.uri().to_string()),
858        Err(err) => {
859            log::warn!("Presigning failed, attempting region discovery: {}", err);
860            let detected_region = {
861                let retry_client = {
862                    let mut s3_manager = s3_state.write().await;
863                    s3_manager.get_client(&active_profile).await?.clone()
864                };
865                crate::s3::get_bucket_region(&retry_client, &bucket_name)
866                    .await
867                    .ok()
868            };
869
870            if let Some(new_region) = detected_region {
871                let new_client = {
872                    let mut s3_manager = s3_state.write().await;
873                    s3_manager.set_bucket_region(&active_profile, &bucket_name, new_region.clone());
874                    s3_manager
875                        .get_client_for_region(&active_profile, &new_region)
876                        .await?
877                        .clone()
878                };
879
880                let mut get_obj = new_client
881                    .get_object()
882                    .bucket(&bucket_name)
883                    .key(&key)
884                    .response_content_disposition("inline");
885
886                if key.to_lowercase().ends_with(".pdf") {
887                    get_obj = get_obj.response_content_type("application/pdf");
888                }
889
890                let presigning_config =
891                    PresigningConfig::expires_in(Duration::from_secs(expires_in))
892                        .map_err(|e| crate::error::AppError::S3Error(e.to_string()))?;
893
894                let req = get_obj.presigned(presigning_config).await.map_err(|e| {
895                    crate::error::AppError::S3Error(format!("Retry presign failed: {}", e))
896                })?;
897                Ok(req.uri().to_string())
898            } else {
899                Err(err)
900            }
901        }
902    }
903}
904
905#[derive(Serialize)]
906pub struct ObjectText {
907    content: String,
908    e_tag: Option<String>,
909    profile_id: String,
910}
911
912#[tauri::command]
913pub async fn get_object_content(
914    bucket_name: String,
915    bucket_region: Option<String>,
916    key: String,
917    max_bytes: Option<u64>,
918    expected_profile_id: String,
919    profile_state: State<'_, ProfileState>,
920    s3_state: State<'_, S3State>,
921) -> Result<ObjectText> {
922    let max_bytes = normalized_text_preview_limit(max_bytes);
923    let profile_manager = profile_state.read().await;
924    let active_profile = profile_manager
925        .get_active_profile()
926        .await?
927        .ok_or_else(|| crate::error::AppError::ProfileNotFound("No active profile".into()))?;
928    drop(profile_manager);
929    super::operations::validate_operation_profile(Some(&expected_profile_id), &active_profile.id)?;
930
931    let bucket_region = {
932        let s3_manager = s3_state.read().await;
933        s3_manager.get_bucket_region(&active_profile, &bucket_name)
934    }
935    .or(bucket_region);
936
937    let client = {
938        let mut s3_manager = s3_state.write().await;
939        if let Some(ref region) = bucket_region {
940            s3_manager
941                .get_client_for_region(&active_profile, region)
942                .await?
943                .clone()
944        } else {
945            s3_manager.get_client(&active_profile).await?.clone()
946        }
947    };
948
949    let result = client
950        .get_object()
951        .bucket(&bucket_name)
952        .key(&key)
953        .send()
954        .await;
955
956    let response = match result {
957        Ok(res) => res,
958        Err(err) => {
959            log::warn!(
960                "get_object_content failed, attempting region discovery: {}",
961                err
962            );
963            let detected_region = {
964                let retry_client = {
965                    let mut s3_manager = s3_state.write().await;
966                    s3_manager.get_client(&active_profile).await?.clone()
967                };
968                crate::s3::get_bucket_region(&retry_client, &bucket_name)
969                    .await
970                    .ok()
971            };
972
973            if let Some(new_region) = detected_region {
974                let new_client = {
975                    let mut s3_manager = s3_state.write().await;
976                    s3_manager.set_bucket_region(&active_profile, &bucket_name, new_region.clone());
977                    s3_manager
978                        .get_client_for_region(&active_profile, &new_region)
979                        .await?
980                        .clone()
981                };
982                new_client
983                    .get_object()
984                    .bucket(&bucket_name)
985                    .key(&key)
986                    .send()
987                    .await
988                    .map_err(|e| {
989                        crate::error::AppError::S3Error(format!("Retry get content failed: {}", e))
990                    })?
991            } else {
992                return Err(crate::error::AppError::S3Error(err.to_string()));
993            }
994        }
995    };
996
997    let content_length = response
998        .content_length()
999        .and_then(|length| u64::try_from(length).ok());
1000    if content_length.is_some_and(|length| length > max_bytes) {
1001        return Err(text_preview_size_error(content_length, max_bytes));
1002    }
1003
1004    let initial_capacity = content_length
1005        .unwrap_or(0)
1006        .min(max_bytes)
1007        .try_into()
1008        .unwrap_or(0);
1009    let mut bytes = Vec::with_capacity(initial_capacity);
1010    let e_tag = response.e_tag.clone();
1011    let mut body = response.body;
1012
1013    while let Some(chunk) = body
1014        .try_next()
1015        .await
1016        .map_err(|e| crate::error::AppError::S3Error(e.to_string()))?
1017    {
1018        if !preview_chunk_fits(bytes.len(), chunk.len(), max_bytes) {
1019            return Err(text_preview_size_error(None, max_bytes));
1020        }
1021        bytes.extend_from_slice(&chunk);
1022    }
1023
1024    if is_likely_binary_text_mismatch(&bytes) {
1025        return Err(crate::error::AppError::InvalidContent(
1026            "This object appears to contain binary data and cannot be edited safely in the text editor. Download it to inspect locally.".to_string(),
1027        ));
1028    }
1029
1030    let content = String::from_utf8(bytes).map_err(|_| {
1031        crate::error::AppError::InvalidContent(
1032            "This object is not readable as UTF-8 text. Download it to inspect locally."
1033                .to_string(),
1034        )
1035    })?;
1036    Ok(ObjectText {
1037        content,
1038        e_tag,
1039        profile_id: active_profile.id,
1040    })
1041}
1042
1043#[tauri::command]
1044#[allow(clippy::too_many_arguments)]
1045pub async fn put_object_content(
1046    bucket_name: String,
1047    bucket_region: Option<String>,
1048    key: String,
1049    content: String,
1050    expected_etag: String,
1051    expected_profile_id: String,
1052    profile_state: State<'_, ProfileState>,
1053    s3_state: State<'_, S3State>,
1054) -> Result<Option<String>> {
1055    let profile_manager = profile_state.read().await;
1056    let active_profile = profile_manager
1057        .get_active_profile()
1058        .await?
1059        .ok_or_else(|| crate::error::AppError::ProfileNotFound("No active profile".into()))?;
1060    drop(profile_manager);
1061    super::operations::validate_operation_profile(Some(&expected_profile_id), &active_profile.id)?;
1062
1063    let bucket_region = {
1064        let s3_manager = s3_state.read().await;
1065        s3_manager.get_bucket_region(&active_profile, &bucket_name)
1066    }
1067    .or(bucket_region);
1068
1069    let client = {
1070        let mut s3_manager = s3_state.write().await;
1071        if let Some(ref region) = bucket_region {
1072            s3_manager
1073                .get_client_for_region(&active_profile, region)
1074                .await?
1075                .clone()
1076        } else {
1077            s3_manager.get_client(&active_profile).await?.clone()
1078        }
1079    };
1080
1081    let result =
1082        super::operations::save_object_text(&client, &bucket_name, &key, content, &expected_etag)
1083            .await;
1084
1085    {
1086        let mut s3_manager = s3_state.write().await;
1087        s3_manager.remove_bucket_cache(&active_profile.id, &bucket_name);
1088    }
1089
1090    result
1091}
1092
1093#[cfg(test)]
1094mod preview_tests {
1095    use super::{
1096        normalized_text_preview_limit, preview_chunk_fits, DEFAULT_MAX_TEXT_PREVIEW_BYTES,
1097        MAX_TEXT_PREVIEW_BYTES,
1098    };
1099
1100    #[test]
1101    fn text_preview_limit_has_a_safe_default_and_upper_bound() {
1102        assert_eq!(
1103            normalized_text_preview_limit(None),
1104            DEFAULT_MAX_TEXT_PREVIEW_BYTES
1105        );
1106        assert_eq!(normalized_text_preview_limit(Some(0)), 1);
1107        assert_eq!(
1108            normalized_text_preview_limit(Some(MAX_TEXT_PREVIEW_BYTES + 1)),
1109            MAX_TEXT_PREVIEW_BYTES
1110        );
1111    }
1112
1113    #[test]
1114    fn streamed_preview_never_crosses_the_configured_limit() {
1115        assert!(preview_chunk_fits(6, 4, 10));
1116        assert!(!preview_chunk_fits(6, 5, 10));
1117        assert!(!preview_chunk_fits(usize::MAX, 1, 10));
1118    }
1119}
1120
1121#[cfg(test)]
1122mod pagination_tests {
1123    use super::*;
1124
1125    fn content(count: usize) -> FolderContent {
1126        FolderContent {
1127            generation: "snapshot".to_string(),
1128            objects: (0..count)
1129                .map(|index| S3Object {
1130                    key: index.to_string(),
1131                    size: 0,
1132                    last_modified: None,
1133                    storage_class: None,
1134                })
1135                .collect(),
1136            common_prefixes: vec!["folder/".to_string()],
1137        }
1138    }
1139
1140    #[test]
1141    fn sorted_pages_preserve_objects_and_only_return_folders_once() {
1142        let content = content(3);
1143        let first = paginate_folder_content(&content, String::new(), None, None, Some(2)).unwrap();
1144        assert_eq!(first.objects.len(), 2);
1145        assert_eq!(first.common_prefixes.len(), 1);
1146        let last = paginate_folder_content(
1147            &content,
1148            String::new(),
1149            None,
1150            first.next_continuation_token,
1151            Some(2),
1152        )
1153        .unwrap();
1154        assert_eq!(last.objects[0].key, "2");
1155        assert!(last.common_prefixes.is_empty());
1156        assert!(!last.is_truncated);
1157    }
1158
1159    #[test]
1160    fn stale_and_malformed_sorted_cursors_return_errors() {
1161        for token in [
1162            "1000",
1163            "old:1",
1164            "snapshot:no",
1165            "snapshot:1000",
1166            "snapshot:18446744073709551615",
1167        ] {
1168            assert!(paginate_folder_content(
1169                &content(999),
1170                String::new(),
1171                None,
1172                Some(token.to_string()),
1173                None
1174            )
1175            .is_err());
1176        }
1177        let empty = paginate_folder_content(&content(0), String::new(), None, None, None).unwrap();
1178        assert!(empty.objects.is_empty());
1179        assert!(!empty.is_truncated);
1180    }
1181}