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 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 {
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 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 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 let mut request = client
435 .list_objects_v2()
436 .bucket(&bucket_name)
437 .prefix(&prefix_str);
438
439 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 let output = match result {
455 Ok(out) => out,
456 Err(err) => {
457 log::warn!("Initial list_objects failed: {}", err);
458 let detected_region = {
460 let retry_client = {
462 let s3_manager = s3_state.read().await;
463 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 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 let mut retry_req = new_client
499 .list_objects_v2()
500 .bucket(&bucket_name)
501 .prefix(&prefix_str);
502
503 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 resolved_bucket_region = Some(new_region.clone());
517
518 {
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 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 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 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 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 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); if let Some(ref token) = continuation_token {
666 req = req.continuation_token(token);
667 }
668
669 let result = req.send().await;
670
671 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 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 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 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}