Merge branch 'main' into optimistic-presigned-urls

Author: oscartbeaumont

.claude/settings.local.json

@@ -3,7 +3,8 @@
 		"allow": [
 			"Bash(pnpm typecheck:*)",
 			"Bash(pnpm lint:*)",
-			"Bash(pnpm build:*)"
+			"Bash(pnpm build:*)",
+			"Bash(cargo check:*)"
 		],
 		"deny": [],
 		"ask": []

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "cap-desktop"
-version = "0.3.72"
+version = "0.3.73"
 description = "Beautiful screen recordings, owned by you."
 authors = ["you"]
 edition = "2024"

apps/desktop/src-tauri/Cargo.toml

@@ -5,9 +5,12 @@ use serde::{Deserialize, Serialize};
 use serde_json::json;
 use tauri::AppHandle;
 
-use crate::web_api::ManagerExt;
+use crate::web_api::{AuthedApiError, ManagerExt};
 
-pub async fn upload_multipart_initiate(app: &AppHandle, video_id: &str) -> Result<String, String> {
+pub async fn upload_multipart_initiate(
+    app: &AppHandle,
+    video_id: &str,
+) -> Result<String, AuthedApiError> {
     #[derive(Deserialize)]
     #[serde(rename_all = "camelCase")]
     pub struct Response {
@@ -32,14 +35,12 @@ pub async fn upload_multipart_initiate(app: &AppHandle, video_id: &str) -> Resul
             .text()
             .await
             .unwrap_or_else(|_| "<no response body>".to_string());
-        return Err(format!(
-            "api/upload_multipart_initiate/{status}: {error_body}"
-        ));
+        return Err(format!("api/upload_multipart_initiate/{status}: {error_body}").into());
     }
 
     resp.json::<Response>()
         .await
-        .map_err(|err| format!("api/upload_multipart_initiate/response: {err}"))
+        .map_err(|err| format!("api/upload_multipart_initiate/response: {err}").into())
         .map(|data| data.upload_id)
 }
 
@@ -48,7 +49,7 @@ pub async fn upload_multipart_presign_part(
     video_id: &str,
     upload_id: &str,
     part_number: u32,
-) -> Result<String, String> {
+) -> Result<String, AuthedApiError> {
     #[derive(Deserialize)]
     #[serde(rename_all = "camelCase")]
     pub struct Response {
@@ -74,14 +75,12 @@ pub async fn upload_multipart_presign_part(
             .text()
             .await
             .unwrap_or_else(|_| "<no response body>".to_string());
-        return Err(format!(
-            "api/upload_multipart_presign_part/{status}: {error_body}"
-        ));
+        return Err(format!("api/upload_multipart_presign_part/{status}: {error_body}").into());
     }
 
     resp.json::<Response>()
         .await
-        .map_err(|err| format!("api/upload_multipart_presign_part/response: {err}"))
+        .map_err(|err| format!("api/upload_multipart_presign_part/response: {err}").into())
         .map(|data| data.presigned_url)
 }
 
@@ -112,7 +111,7 @@ pub async fn upload_multipart_complete(
     upload_id: &str,
     parts: &[UploadedPart],
     meta: Option<S3VideoMeta>,
-) -> Result<Option<String>, String> {
+) -> Result<Option<String>, AuthedApiError> {
     #[derive(Serialize)]
     #[serde(rename_all = "camelCase")]
     pub struct MultipartCompleteRequest<'a> {
@@ -148,14 +147,12 @@ pub async fn upload_multipart_complete(
             .text()
             .await
             .unwrap_or_else(|_| "<no response body>".to_string());
-        return Err(format!(
-            "api/upload_multipart_complete/{status}: {error_body}"
-        ));
+        return Err(format!("api/upload_multipart_complete/{status}: {error_body}").into());
     }
 
     resp.json::<Response>()
         .await
-        .map_err(|err| format!("api/upload_multipart_complete/response: {err}"))
+        .map_err(|err| format!("api/upload_multipart_complete/response: {err}").into())
         .map(|data| data.location)
 }
 
@@ -177,7 +174,10 @@ pub struct PresignedS3PutRequest {
     pub meta: Option<S3VideoMeta>,
 }
 
-pub async fn upload_signed(app: &AppHandle, body: PresignedS3PutRequest) -> Result<String, String> {
+pub async fn upload_signed(
+    app: &AppHandle,
+    body: PresignedS3PutRequest,
+) -> Result<String, AuthedApiError> {
     #[derive(Deserialize)]
     struct Data {
         url: String,
@@ -202,12 +202,12 @@ pub async fn upload_signed(app: &AppHandle, body: PresignedS3PutRequest) -> Resu
             .text()
             .await
             .unwrap_or_else(|_| "<no response body>".to_string());
-        return Err(format!("api/upload_signed/{status}: {error_body}"));
+        return Err(format!("api/upload_signed/{status}: {error_body}").into());
     }
 
     resp.json::<Response>()
         .await
-        .map_err(|err| format!("api/upload_signed/response: {err}"))
+        .map_err(|err| format!("api/upload_signed/response: {err}").into())
         .map(|data| data.presigned_put_data.url)
 }
 
@@ -216,7 +216,7 @@ pub async fn desktop_video_progress(
     video_id: &str,
     uploaded: u64,
     total: u64,
-) -> Result<(), String> {
+) -> Result<(), AuthedApiError> {
     let resp = app
         .authed_api_request("/api/desktop/video/progress", |client, url| {
             client.post(url).json(&json!({
@@ -235,7 +235,7 @@ pub async fn desktop_video_progress(
             .text()
             .await
             .unwrap_or_else(|_| "<no response body>".to_string());
-        return Err(format!("api/desktop_video_progress/{status}: {error_body}"));
+        return Err(format!("api/desktop_video_progress/{status}: {error_body}").into());
     }
 
     Ok(())

apps/desktop/src-tauri/src/api.rs

@@ -118,6 +118,3 @@ impl AuthStore {
         store.save().map_err(|e| e.to_string())
     }
 }
-
-#[derive(specta::Type, serde::Serialize, tauri_specta::Event, Debug, Clone, serde::Deserialize)]
-pub struct AuthenticationInvalid;

apps/desktop/src-tauri/src/auth.rs

@@ -138,7 +138,9 @@ impl DeepLinkAction {
                     mode,
                 };
 
-                crate::recording::start_recording(app.clone(), state, inputs).await
+                crate::recording::start_recording(app.clone(), state, inputs)
+                    .await
+                    .map(|_| ())
             }
             DeepLinkAction::StopRecording => {
                 crate::recording::stop_recording(app.clone(), app.state()).await

apps/desktop/src-tauri/src/deeplink_actions.rs

@@ -1,3 +1,4 @@
+use crate::window_exclusion::WindowExclusion;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use specta::Type;
@@ -39,6 +40,24 @@ impl MainWindowRecordingStartBehaviour {
     }
 }
 
+const DEFAULT_EXCLUDED_WINDOW_TITLES: &[&str] = &[
+    "Cap",
+    "Cap Settings",
+    "Cap Recording Controls",
+    "Cap Camera",
+];
+
+pub fn default_excluded_windows() -> Vec<WindowExclusion> {
+    DEFAULT_EXCLUDED_WINDOW_TITLES
+        .iter()
+        .map(|title| WindowExclusion {
+            bundle_identifier: None,
+            owner_name: None,
+            window_title: Some((*title).to_string()),
+        })
+        .collect()
+}
+
 // When adding fields here, #[serde(default)] defines the value to use for existing configurations,
 // and `Default::default` defines the value to use for new configurations.
 // Things that affect the user experience should only be enabled by default for new configurations.
@@ -99,6 +118,8 @@ pub struct GeneralSettingsStore {
     pub post_deletion_behaviour: PostDeletionBehaviour,
     #[serde(default = "default_enable_new_uploader", skip_serializing_if = "no")]
     pub enable_new_uploader: bool,
+    #[serde(default = "default_excluded_windows")]
+    pub excluded_windows: Vec<WindowExclusion>,
 }
 
 fn default_enable_native_camera_preview() -> bool {
@@ -111,7 +132,7 @@ fn default_enable_new_recording_flow() -> bool {
 }
 
 fn default_enable_new_uploader() -> bool {
-    cfg!(debug_assertions)
+    true
 }
 
 fn no(_: &bool) -> bool {
@@ -162,6 +183,7 @@ impl Default for GeneralSettingsStore {
             enable_new_recording_flow: default_enable_new_recording_flow(),
             post_deletion_behaviour: PostDeletionBehaviour::DoNothing,
             enable_new_uploader: default_enable_new_uploader(),
+            excluded_windows: default_excluded_windows(),
         }
     }
 }
@@ -231,3 +253,9 @@ pub fn init(app: &AppHandle) {
 
     println!("GeneralSettingsState managed");
 }
+
+#[tauri::command]
+#[specta::specta]
+pub fn get_default_excluded_windows() -> Vec<WindowExclusion> {
+    default_excluded_windows()
+}

apps/desktop/src-tauri/src/general_settings.rs

@@ -146,9 +146,9 @@ async fn handle_hotkey(app: AppHandle, action: HotkeyAction) -> Result<(), Strin
             Ok(())
         }
         HotkeyAction::StopRecording => recording::stop_recording(app.clone(), app.state()).await,
-        HotkeyAction::RestartRecording => {
-            recording::restart_recording(app.clone(), app.state()).await
-        }
+        HotkeyAction::RestartRecording => recording::restart_recording(app.clone(), app.state())
+            .await
+            .map(|_| ()),
         HotkeyAction::OpenRecordingPicker => {
             let _ = RequestOpenRecordingPicker { target_mode: None }.emit(&app);
             Ok(())

apps/desktop/src-tauri/src/hotkeys.rs

@@ -25,10 +25,11 @@ mod tray;
 mod upload;
 mod upload_legacy;
 mod web_api;
+mod window_exclusion;
 mod windows;
 
 use audio::AppSounds;
-use auth::{AuthStore, AuthenticationInvalid, Plan};
+use auth::{AuthStore, Plan};
 use camera::CameraPreviewState;
 use cap_editor::{EditorInstance, EditorState};
 use cap_project::{
@@ -87,6 +88,7 @@ use tokio::sync::Mutex;
 use tokio::sync::{RwLock, oneshot};
 use tracing::{error, trace, warn};
 use upload::{create_or_get_video, upload_image, upload_video};
+use web_api::AuthedApiError;
 use web_api::ManagerExt as WebManagerExt;
 use windows::{CapWindowId, EditorWindowIds, ShowCapWindow, set_window_transparent};
 
@@ -1084,7 +1086,7 @@ async fn upload_exported_video(
 
     channel.send(UploadProgress { progress: 0.0 }).ok();
 
-    let s3_config = async {
+    let s3_config = match async {
         let video_id = match mode {
             UploadMode::Initial { pre_created_video } => {
                 if let Some(pre_created) = pre_created_video {
@@ -1094,7 +1096,7 @@ async fn upload_exported_video(
             }
             UploadMode::Reupload => {
                 let Some(sharing) = meta.sharing.clone() else {
-                    return Err("No sharing metadata found".to_string());
+                    return Err("No sharing metadata found".into());
                 };
 
                 Some(sharing.id)
@@ -1110,7 +1112,13 @@ async fn upload_exported_video(
         )
         .await
     }
-    .await?;
+    .await
+    {
+        Ok(data) => data,
+        Err(AuthedApiError::InvalidAuthentication) => return Ok(UploadResult::NotAuthenticated),
+        Err(AuthedApiError::UpgradeRequired) => return Ok(UploadResult::UpgradeRequired),
+        Err(err) => return Err(err.to_string()),
+    };
 
     let screenshot_path = meta.project_path.join("screenshots/display.jpg");
     meta.upload = Some(UploadMeta::SinglePartUpload {
@@ -1154,17 +1162,20 @@ async fn upload_exported_video(
             NotificationType::ShareableLinkCopied.send(&app);
             Ok(UploadResult::Success(uploaded_video.link))
         }
+        Err(AuthedApiError::UpgradeRequired) => Ok(UploadResult::UpgradeRequired),
         Err(e) => {
             error!("Failed to upload video: {e}");
 
             NotificationType::UploadFailed.send(&app);
 
-            meta.upload = Some(UploadMeta::Failed { error: e.clone() });
+            meta.upload = Some(UploadMeta::Failed {
+                error: e.to_string(),
+            });
             meta.save_for_project()
                 .map_err(|e| error!("Failed to save recording meta: {e}"))
                 .ok();
 
-            Err(e)
+            Err(e.to_string().into())
         }
     }
 }
@@ -1597,16 +1608,10 @@ async fn check_upgraded_and_update(app: AppHandle) -> Result<bool, String> {
         .await
         .map_err(|e| {
             println!("Failed to fetch plan: {e}");
-            format!("Failed to fetch plan: {e}")
+            e.to_string()
         })?;
 
     println!("Plan fetch response status: {}", response.status());
-    if response.status() == reqwest::StatusCode::UNAUTHORIZED {
-        println!("Unauthorized response, clearing auth store");
-        AuthStore::set(&app, None).map_err(|e| e.to_string())?;
-        return Ok(false);
-    }
-
     let plan_data = response.json::<serde_json::Value>().await.map_err(|e| {
         println!("Failed to parse plan response: {e}");
         format!("Failed to parse plan response: {e}")
@@ -1914,6 +1919,8 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
             recording::list_capture_displays,
             recording::list_displays_with_thumbnails,
             recording::list_windows_with_thumbnails,
+            windows::refresh_window_content_protection,
+            general_settings::get_default_excluded_windows,
             take_screenshot,
             list_audio_devices,
             close_recordings_overlay_window,
@@ -1998,7 +2005,6 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
             RequestOpenSettings,
             RequestScreenCapturePrewarm,
             NewNotification,
-            AuthenticationInvalid,
             audio_meter::AudioInputLevelChange,
             captions::DownloadProgress,
             recording::RecordingEvent,
@@ -2014,7 +2020,8 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
         .typ::<hotkeys::HotkeysStore>()
         .typ::<general_settings::GeneralSettingsStore>()
         .typ::<recording_settings::RecordingSettingsStore>()
-        .typ::<cap_flags::Flags>();
+        .typ::<cap_flags::Flags>()
+        .typ::<crate::window_exclusion::WindowExclusion>();
 
     #[cfg(debug_assertions)]
     specta_builder
@@ -2114,7 +2121,7 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
                     CapWindowId::CaptureArea.label().as_str(),
                     CapWindowId::Camera.label().as_str(),
                     CapWindowId::RecordingsOverlay.label().as_str(),
-                    CapWindowId::InProgressRecording.label().as_str(),
+                    CapWindowId::RecordingControls.label().as_str(),
                     CapWindowId::Upgrade.label().as_str(),
                 ])
                 .map_label(|label| match label {
@@ -2548,7 +2555,7 @@ async fn resume_uploads(app: AppHandle) -> Result<(), String> {
                                         error!("Error completing resumed upload for video: {error}");
 
                                         if let Ok(mut meta) = RecordingMeta::load_for_project(&recording_dir).map_err(|err| error!("Error loading project metadata: {err}")) {
-                                            meta.upload = Some(UploadMeta::Failed { error });
+                                            meta.upload = Some(UploadMeta::Failed { error: error.to_string() });
                                             meta.save_for_project().map_err(|err| error!("Error saving project metadata: {err}")).ok();
                                         }
                                     })