feat: Deeplinks Support + Raycast Extension

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

@@ -25,13 +25,24 @@ pub enum DeepLinkAction {
         capture_system_audio: bool,
         mode: RecordingMode,
     },
+    StartDefaultRecording,
     StopRecording,
     OpenEditor {
         project_path: PathBuf,
     },
     OpenSettings {
         page: Option<String>,
     },
+    PauseRecording,
+    ResumeRecording,
+    SetMicrophone {
+        label: Option<String>,
+    },
+    SetCamera {
+        id: Option<DeviceOrModelID>,
+    },
+    CycleMicrophone,
+    CycleCamera,
 }
 
 pub fn handle(app_handle: &AppHandle, urls: Vec<Url>) {
@@ -143,6 +154,25 @@ impl DeepLinkAction {
                     .await
                     .map(|_| ())
             }
+            DeepLinkAction::StartDefaultRecording => {
+                 let displays = cap_recording::screen_capture::list_displays();
+                 if let Some((display, _)) = displays.first() {
+                    let state = app.state::<ArcLock<App>>();
+
+                    let inputs = StartRecordingInputs {
+                        mode: RecordingMode::Instant,
+                        capture_target: ScreenCaptureTarget::Display { id: display.id },
+                        capture_system_audio: false, 
+                        organization_id: None,
+                    };
+
+                    crate::recording::start_recording(app.clone(), state, inputs)
+                        .await
+                        .map(|_| ())
+                 } else {
+                     Err("No displays found".to_string())
+                 }
+            }
             DeepLinkAction::StopRecording => {
                 crate::recording::stop_recording(app.clone(), app.state()).await
             }
@@ -152,6 +182,30 @@ impl DeepLinkAction {
             DeepLinkAction::OpenSettings { page } => {
                 crate::show_window(app.clone(), ShowCapWindow::Settings { page }).await
             }
+            DeepLinkAction::PauseRecording => {
+                let state = app.state::<ArcLock<App>>();
+                crate::pause_recording(state).await
+            }
+            DeepLinkAction::ResumeRecording => {
+                let state = app.state::<ArcLock<App>>();
+                crate::resume_recording(state).await
+            }
+            DeepLinkAction::SetMicrophone { label } => {
+                let state = app.state::<ArcLock<App>>();
+                crate::set_mic_input(state, label).await
+            }
+            DeepLinkAction::SetCamera { id } => {
+                let state = app.state::<ArcLock<App>>();
+                crate::set_camera_input(app.clone(), state, id).await
+            }
+            DeepLinkAction::CycleMicrophone => {
+                let state = app.state::<ArcLock<App>>();
+                crate::cycle_mic_input(state).await
+            }
+            DeepLinkAction::CycleCamera => {
+                let state = app.state::<ArcLock<App>>();
+                crate::cycle_camera_input(app.clone(), state).await
+            }
         }
     }
 }

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

@@ -588,6 +588,99 @@ async fn set_camera_input(
     Ok(())
 }
 
+#[tauri::command]
+#[specta::specta]
+#[instrument(skip(state))]
+pub async fn pause_recording(state: MutableState<'_, App>) -> Result<(), String> {
+    let mut app = state.write().await;
+    if let Some(recording) = app.current_recording_mut() {
+        recording.pause().await.map_err(|e| e.to_string())?;
+    }
+    Ok(())
+}
+
+#[tauri::command]
+#[specta::specta]
+#[instrument(skip(state))]
+pub async fn resume_recording(state: MutableState<'_, App>) -> Result<(), String> {
+    let mut app = state.write().await;
+    if let Some(recording) = app.current_recording_mut() {
+        recording.resume().await.map_err(|e| e.to_string())?;
+    }
+    Ok(())
+}
+
+#[tauri::command]
+#[specta::specta]
+#[instrument(skip(state))]
+pub async fn cycle_mic_input(state: MutableState<'_, App>) -> Result<(), String> {
+    let (current_label, mic_list) = {
+        let app = state.read().await;
+        let mic_list = MicrophoneFeed::list().keys().cloned().collect::<Vec<_>>();
+        (app.selected_mic_label.clone(), mic_list)
+    };
+
+    if mic_list.is_empty() {
+        return Ok(());
+    }
+
+    let next_label = match current_label {
+        Some(label) => {
+            let index = mic_list.iter().position(|l| l == &label);
+            match index {
+                Some(i) => mic_list.get((i + 1) % mic_list.len()).cloned(),
+                None => mic_list.first().cloned(),
+            }
+        }
+        None => mic_list.first().cloned(),
+    };
+
+    set_mic_input(state, next_label).await
+}
+
+#[tauri::command]
+#[specta::specta]
+#[instrument(skip(app_handle, state))]
+pub async fn cycle_camera_input(
+    app_handle: AppHandle,
+    state: MutableState<'_, App>
+) -> Result<(), String> {
+    let (current_id, camera_list) = {
+        let app = state.read().await;
+        let camera_list = cap_camera::list_cameras().collect::<Vec<_>>();
+        (app.selected_camera_id.clone(), camera_list)
+    };
+
+    if camera_list.is_empty() {
+        return Ok(());
+    }
+
+    let next_id = match current_id {
+        Some(id) => {
+            let current_dev_id = match id {
+                DeviceOrModelID::DeviceID(d) => Some(d),
+                DeviceOrModelID::ModelID(_) => None, 
+            };
+
+            let index = if let Some(dev_id) = current_dev_id {
+                camera_list.iter().position(|c| c.device_id() == dev_id)
+            } else {
+                None
+            };
+
+            match index { 
+                Some(i) => camera_list.get((i + 1) % camera_list.len()),
+                None => camera_list.first(),
+            }
+        }
+        None => camera_list.first(),
+    };
+
+    let next_id = next_id.map(|c| DeviceOrModelID::DeviceID(c.device_id().to_string()));
+
+    set_camera_input(app_handle, state, next_id).await
+}
+
 fn spawn_mic_error_handler(app_handle: AppHandle, error_rx: flume::Receiver<StreamError>) {
     tokio::spawn(async move {
         let state = app_handle.state::<ArcLock<App>>();

apps/raycast-extension/README.md

@@ -0,0 +1,19 @@
+# Cap Control Raycast Extension
+
+Control the Cap desktop app from Raycast.
+
+## Commands
+
+- **Start Recording**: Starts a new recording (defaults to first display).
+- **Stop Recording**: Stops the current recording.
+- **Pause Recording**: Pauses the current recording.
+- **Resume Recording**: Resumes the current recording.
+- **Switch Camera**: Cycles through available cameras.
+- **Switch Microphone**: Cycles through available microphones.
+
+## Installation
+
+1. `cd apps/raycast-extension`
+2. `npm install`
+3. `npm run build`
+4. Import into Raycast via "Import Extension".

apps/raycast-extension/package.json

@@ -0,0 +1,71 @@
+{
+    "$schema": "https://www.raycast.com/schemas/extension.json",
+    "name": "cap-control",
+    "title": "Cap Control",
+    "description": "Control Cap desktop app",
+    "icon": "command-icon.png",
+    "author": "CapSoftware",
+    "categories": [
+        "Productivity",
+        "Media"
+    ],
+    "license": "MIT",
+    "commands": [
+        {
+            "name": "start-recording",
+            "title": "Start Recording",
+            "description": "Start a new recording",
+            "mode": "no-view"
+        },
+        {
+            "name": "stop-recording",
+            "title": "Stop Recording",
+            "description": "Stop current recording",
+            "mode": "no-view"
+        },
+        {
+            "name": "pause-recording",
+            "title": "Pause Recording",
+            "description": "Pause current recording",
+            "mode": "no-view"
+        },
+        {
+            "name": "resume-recording",
+            "title": "Resume Recording",
+            "description": "Resume current recording",
+            "mode": "no-view"
+        },
+        {
+            "name": "switch-camera",
+            "title": "Switch Camera",
+            "description": "Cycle through available cameras",
+            "mode": "no-view"
+        },
+        {
+            "name": "switch-microphone",
+            "title": "Switch Microphone",
+            "description": "Cycle through available microphones",
+            "mode": "no-view"
+        }
+    ],
+    "dependencies": {
+        "@raycast/api": "^1.69.0",
+        "@raycast/utils": "^1.13.0"
+    },
+    "devDependencies": {
+        "@raycast/eslint-config": "^1.0.6",
+        "@types/node": "20.8.10",
+        "@types/react": "18.2.27",
+        "eslint": "^8.51.0",
+        "prettier": "^3.0.3",
+        "typescript": "^5.2.2"
+    },
+    "scripts": {
+        "build": "ray build -e dist",
+        "dev": "ray develop",
+        "fix-lint": "ray lint --fix",
+        "lint": "ray lint",
+        "prepublishOnly": "echo \"\\n\\nIt seems like you are trying to publish the Raycast extension to npm.\\n\\nIf you did intend to publish it to npm, remove the \\`prepublishOnly\\` script and rerun \\`npm publish\\` again.\\nIf you wanted to publish it to the Raycast Store instead, use \\`npm run publish\\` instead.\\n\\n\" && exit 1",
+        "publish": "npx @raycast/api@latest publish"
+    }
+}

apps/raycast-extension/src/pause-recording.tsx

@@ -0,0 +1,5 @@
+import { sendCapCommand } from "./utils";
+
+export default async function Command() {
+    await sendCapCommand("pause_recording", "Recording Paused");
+}

apps/raycast-extension/src/resume-recording.tsx

@@ -0,0 +1,5 @@
+import { sendCapCommand } from "./utils";
+
+export default async function Command() {
+    await sendCapCommand("resume_recording", "Recording Resumed");
+}

apps/raycast-extension/src/start-recording.tsx

@@ -0,0 +1,5 @@
+import { sendCapCommand } from "./utils";
+
+export default async function Command() {
+    await sendCapCommand("start_default_recording", "Recording Started");
+}

apps/raycast-extension/src/stop-recording.tsx

@@ -0,0 +1,5 @@
+import { sendCapCommand } from "./utils";
+
+export default async function Command() {
+    await sendCapCommand("stop_recording", "Recording Stopped");
+}

apps/raycast-extension/src/switch-camera.tsx

@@ -0,0 +1,5 @@
+import { sendCapCommand } from "./utils";
+
+export default async function Command() {
+    await sendCapCommand("cycle_camera", "Switching Camera...");
+}

apps/raycast-extension/src/switch-microphone.tsx

@@ -0,0 +1,5 @@
+import { sendCapCommand } from "./utils";
+
+export default async function Command() {
+    await sendCapCommand("cycle_microphone", "Switching Microphone...");
+}

apps/raycast-extension/src/utils.ts

@@ -0,0 +1,16 @@
+import { open, showHUD, closeMainWindow } from "@raycast/api";
+
+export async function sendCapCommand(action: string | object, hudMessage: string) {
+    try {
+        await closeMainWindow();
+        // If action is a string, it's a unit variant (e.g. "stop_recording")
+        // If it's an object, it's a struct variant (e.g. { "start_recording": ... })
+        const jsonValue = JSON.stringify(action);
+        const url = `cap-desktop://action?value=${encodeURIComponent(jsonValue)}`;
+        await open(url);
+        await showHUD(hudMessage);
+    } catch (error) {
+        console.error(error);
+        await showHUD("Failed to connect to Cap");
+    }
+}

apps/raycast-extension/tsconfig.json

@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "lib": [
+            "ES2023"
+        ],
+        "module": "commonjs",
+        "target": "ES2023",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "sourceMap": true,
+        "jsx": "react",
+        "moduleResolution": "Node",
+        "resolveJsonModule": true
+    },
+    "include": [
+        "src/**/*"
+    ]
+}