feat(recording): add AudioOnly capture target and recording pipeline …

apps/cli/src/project.rs

@@ -123,10 +123,13 @@ fn studio_checks(meta: &RecordingMeta, studio: &StudioRecordingMeta) -> Vec<File
 
     match studio {
         StudioRecordingMeta::SingleSegment { segment } => {
-            checks.push(required_check(
-                "displayVideo",
-                meta.path(&segment.display.path),
-            ));
+            if !meta.audio_only {
+                let path = segment
+                    .display
+                    .as_ref()
+                    .map_or_else(PathBuf::new, |d| meta.path(&d.path));
+                checks.push(required_check("displayVideo", path));
+            }
             if let Some(camera) = &segment.camera {
                 checks.push(required_check("camera", meta.path(&camera.path)));
             }
@@ -139,10 +142,13 @@ fn studio_checks(meta: &RecordingMeta, studio: &StudioRecordingMeta) -> Vec<File
         }
         StudioRecordingMeta::MultipleSegments { inner } => {
             for segment in &inner.segments {
-                checks.push(required_check(
-                    "displayVideo",
-                    meta.path(&segment.display.path),
-                ));
+                if !meta.audio_only {
+                    let path = segment
+                        .display
+                        .as_ref()
+                        .map_or_else(PathBuf::new, |d| meta.path(&d.path));
+                    checks.push(required_check("displayVideo", path));
+                }
                 if let Some(camera) = &segment.camera {
                     checks.push(required_check("camera", meta.path(&camera.path)));
                 }

apps/cli/src/record.rs

@@ -906,6 +906,7 @@ fn persist_instant_recording_meta(
         sharing: None,
         inner: RecordingMetaInner::Instant(meta),
         upload: None,
+        audio_only: false,
     }
     .save_for_project()
     .map_err(|e| format!("Failed to save instant recording meta: {e}"))?;

apps/desktop/src-tauri/examples/desktop-display-transport-benchmark.rs

@@ -118,7 +118,11 @@ async fn load_recording(
     if project.timeline.is_none() {
         let timeline_segments = match meta.as_ref() {
             StudioRecordingMeta::SingleSegment { segment } => {
-                let display_path = recording_meta.path(&segment.display.path);
+                let display_path = segment
+                    .display
+                    .as_ref()
+                    .map(|d| recording_meta.path(&d.path))
+                    .unwrap_or_default();
                 let duration = match Video::new(&display_path, 0.0) {
                     Ok(video) => video.duration,
                     Err(_) => 5.0,
@@ -136,7 +140,11 @@ async fn load_recording(
                 .iter()
                 .enumerate()
                 .filter_map(|(i, segment)| {
-                    let display_path = recording_meta.path(&segment.display.path);
+                    let display_path = segment
+                        .display
+                        .as_ref()
+                        .map(|d| recording_meta.path(&d.path))
+                        .unwrap_or_default();
                     let duration = match Video::new(&display_path, 0.0) {
                         Ok(video) => video.duration,
                         Err(_) => 5.0,

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

@@ -315,7 +315,8 @@ fn full_timeline_for_segments(
         .iter()
         .enumerate()
         .map(|(index, segment)| {
-            let duration = get_video_duration_secs(&segment.display.path.to_path(project_path))?;
+            let display = segment.display.as_ref().ok_or("Missing display video")?;
+            let duration = get_video_duration_secs(&display.path.to_path(project_path))?;
             Ok(TimelineSegment {
                 recording_clip: index as u32,
                 timescale: 1.0,
@@ -348,7 +349,10 @@ fn full_timeline_for_source_segments(
         .iter()
         .enumerate()
         .map(|(index, segment)| {
-            let duration = get_source_video_duration_secs(source_meta, &segment.display)?;
+            let duration = get_source_video_duration_secs(
+                source_meta,
+                segment.display.as_ref().ok_or("Missing display video")?,
+            )?;
             Ok(TimelineSegment {
                 recording_clip: index as u32,
                 timescale: 1.0,
@@ -595,7 +599,11 @@ fn copy_keyboard_path(
         return Ok(Some(target_relative_path));
     };
 
-    let Some(display_dir) = source_segment.display.path.parent() else {
+    let Some(display_dir) = source_segment
+        .display
+        .as_ref()
+        .and_then(|d| d.path.parent())
+    else {
         return Ok(None);
     };
 
@@ -872,7 +880,13 @@ fn source_timeline_segments_for_import(
         let max_duration = if let Some(duration) = duration_cache.get(&source_index) {
             *duration
         } else {
-            let duration = get_source_video_duration_secs(source_meta, &source_segment.display)?;
+            let duration = get_source_video_duration_secs(
+                source_meta,
+                source_segment
+                    .display
+                    .as_ref()
+                    .ok_or("Missing display video")?,
+            )?;
             duration_cache.insert(source_index, duration);
             duration
         };
@@ -924,15 +938,21 @@ fn copy_source_segment(
     target_relative_dir: &str,
     cursor_id_map: &HashMap<String, String>,
 ) -> Result<MultipleSegment, String> {
-    let display = copy_video_meta(
-        &source_meta.project_path,
-        target_project_path,
-        &source_segment.display,
-        target_relative_dir,
-        "display",
-        true,
-    )?
-    .ok_or_else(|| "Missing display video".to_string())?;
+    let display = source_segment
+        .display
+        .as_ref()
+        .map(|d| {
+            copy_video_meta(
+                &source_meta.project_path,
+                target_project_path,
+                d,
+                target_relative_dir,
+                "display",
+                true,
+            )
+        })
+        .transpose()?
+        .flatten();
 
     let camera = source_segment
         .camera
@@ -1408,12 +1428,12 @@ pub async fn start_video_import(app: AppHandle, source_path: PathBuf) -> Result<
         inner: RecordingMetaInner::Studio(Box::new(StudioRecordingMeta::MultipleSegments {
             inner: MultipleSegments {
                 segments: vec![MultipleSegment {
-                    display: VideoMeta {
+                    display: Some(VideoMeta {
                         path: RelativePathBuf::from("content/segments/segment-0/display.mp4"),
                         fps: 30,
                         start_time: Some(0.0),
                         device_id: None,
-                    },
+                    }),
                     camera: None,
                     mic: None,
                     system_audio: None,
@@ -1425,6 +1445,7 @@ pub async fn start_video_import(app: AppHandle, source_path: PathBuf) -> Result<
             },
         })),
         upload: None,
+        audio_only: false,
     };
 
     initial_meta
@@ -1501,14 +1522,14 @@ pub async fn start_video_import(app: AppHandle, source_path: PathBuf) -> Result<
                         StudioRecordingMeta::MultipleSegments {
                             inner: MultipleSegments {
                                 segments: vec![MultipleSegment {
-                                    display: VideoMeta {
+                                    display: Some(VideoMeta {
                                         path: RelativePathBuf::from(
                                             "content/segments/segment-0/display.mp4",
                                         ),
                                         fps,
                                         start_time: Some(0.0),
                                         device_id: None,
-                                    },
+                                    }),
                                     camera: None,
                                     mic: None,
                                     system_audio,
@@ -1521,6 +1542,7 @@ pub async fn start_video_import(app: AppHandle, source_path: PathBuf) -> Result<
                         },
                     )),
                     upload: None,
+                    audio_only: false,
                 };
 
                 if let Err(e) = meta.save_for_project() {
@@ -1677,12 +1699,12 @@ async fn append_mp4_to_editor_project(
     };
 
     let imported_segment = MultipleSegment {
-        display: VideoMeta {
+        display: Some(VideoMeta {
             path: output_video_relative_path,
             fps,
             start_time: Some(0.0),
             device_id: None,
-        },
+        }),
         camera: None,
         mic: None,
         system_audio,
@@ -1971,7 +1993,7 @@ pub async fn start_image_import(app: AppHandle, source_path: PathBuf) -> Result<
     };
 
     let segment = SingleSegment {
-        display: video_meta,
+        display: Some(video_meta),
         camera: None,
         audio: None,
         cursor: None,
@@ -1984,6 +2006,7 @@ pub async fn start_image_import(app: AppHandle, source_path: PathBuf) -> Result<
         sharing: None,
         inner: RecordingMetaInner::Studio(Box::new(StudioRecordingMeta::SingleSegment { segment })),
         upload: None,
+        audio_only: false,
     };
 
     meta.save_for_project()

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

@@ -2240,6 +2240,7 @@ enum CurrentRecordingTarget {
         bounds: LogicalBounds,
     },
     Camera,
+    Audio,
 }
 
 #[derive(Serialize, Type)]
@@ -2292,6 +2293,7 @@ async fn get_current_recording(
             bounds: *bounds,
         },
         ScreenCaptureTarget::CameraOnly => CurrentRecordingTarget::Camera,
+        ScreenCaptureTarget::AudioOnly => CurrentRecordingTarget::Audio,
     };
 
     Ok(JsonValue::new(&Some(CurrentRecording {
@@ -2930,12 +2932,27 @@ async fn get_video_metadata(path: PathBuf) -> Result<VideoRecordingMetadata, Str
 
             match &**meta {
                 StudioRecordingMeta::SingleSegment { segment } => {
-                    vec![recording_meta.path(&segment.display.path)]
+                    vec![
+                        recording_meta.path(
+                            &segment
+                                .display
+                                .as_ref()
+                                .map(|d| d.path.clone())
+                                .unwrap_or_default(),
+                        ),
+                    ]
                 }
                 StudioRecordingMeta::MultipleSegments { inner } => inner
                     .segments
                     .iter()
-                    .map(|s| recording_meta.path(&s.display.path))
+                    .map(|s| {
+                        recording_meta.path(
+                            &s.display
+                                .as_ref()
+                                .map(|d| d.path.clone())
+                                .unwrap_or_default(),
+                        )
+                    })
                     .collect(),
             }
         }