feat: add deeplinks support and Raycast extension

apps/desktop/src/App.tsx

@@ -15,6 +15,7 @@ import "./styles/theme.css";
 import { CapErrorBoundary } from "./components/CapErrorBoundary";
 import { generalSettingsStore } from "./store";
 import { initAnonymousUser } from "./utils/analytics";
+import { initDeepLinkCommands } from "./utils/deep-link-commands";
 import { type AppTheme, commands } from "./utils/tauri";
 import titlebar from "./utils/titlebar-state";
 
@@ -102,6 +103,7 @@ function Inner() {
 
 	onMount(() => {
 		initAnonymousUser();
+		initDeepLinkCommands();
 	});
 
 	return (

apps/desktop/src/utils/deep-link-commands.ts

@@ -0,0 +1,230 @@
+import { listen } from "@tauri-apps/api/event";
+import { onOpenUrl } from "@tauri-apps/plugin-deep-link";
+import { commands } from "./tauri";
+import type { RecordingMode, StartRecordingInputs } from "./tauri";
+
+/**
+ * Deep link command handlers for Cap
+ * Supports: cap://record, cap://stop, cap://pause, cap://resume, 
+ *           cap://toggle-pause, cap://switch-mic, cap://switch-camera
+ */
+
+export interface DeepLinkCommand {
+  action: "record" | "stop" | "pause" | "resume" | "toggle-pause" | "switch-mic" | "switch-camera";
+  params?: Record<string, string>;
+}
+
+/**
+ * Parse deep link URL and extract command
+ */
+export function parseDeepLinkCommand(url: string): DeepLinkCommand | null {
+  try {
+    const urlObj = new URL(url);
+
+    // Only handle cap:// protocol
+    if (urlObj.protocol !== "cap:") {
+      return null;
+    }
+
+    const action = urlObj.hostname as DeepLinkCommand["action"];
+    const params: Record<string, string> = {};
+
+    urlObj.searchParams.forEach((value, key) => {
+      params[key] = value;
+    });
+
+    // Validate action
+    const validActions: DeepLinkCommand["action"][] = [
+      "record", "stop", "pause", "resume", "toggle-pause", "switch-mic", "switch-camera"
+    ];
+
+    if (!validActions.includes(action)) {
+      console.warn(`Unknown deep link action: ${action}`);
+      return null;
+    }
+
+    return { action, params };
+  } catch (error) {
+    console.error("Failed to parse deep link:", error);
+    return null;
+  }
+}
+
+/**
+ * Execute deep link command
+ */
+export async function executeDeepLinkCommand(command: DeepLinkCommand): Promise<void> {
+  const { action, params = {} } = command;
+
+  console.log(`Executing deep link command: ${action}`, params);
+
+  switch (action) {
+    case "record":
+      await handleRecordCommand(params);
+      break;
+    case "stop":
+      await handleStopCommand();
+      break;
+    case "pause":
+      await handlePauseCommand();
+      break;
+    case "resume":
+      await handleResumeCommand();
+      break;
+    case "toggle-pause":
+      await handleTogglePauseCommand();
+      break;
+    case "switch-mic":
+      await handleSwitchMicCommand(params);
+      break;
+    case "switch-camera":
+      await handleSwitchCameraCommand(params);
+      break;
+    default:
+      console.warn(`Unhandled deep link action: ${action}`);
+  }
+}
+
+/**
+ * Handle record command
+ * Params: mode ("instant" | "studio"), camera?, microphone?
+ */
+async function handleRecordCommand(params: Record<string, string>): Promise<void> {
+  const mode = (params.mode as RecordingMode) || "instant";
+
+  // Set recording mode
+  await commands.setRecordingMode(mode);
+
+  const inputs: StartRecordingInputs = {
+    mode,
+    capture_target: params.target || "screen",
+  };
+
+  // Add camera if specified
+  if (params.camera) {
+    inputs.camera_label = params.camera;
+  }
+
+  // Add microphone if specified
+  if (params.microphone) {
+    inputs.audio_inputs = [{ label: params.microphone, device_type: "mic" }];
+  }
+
+  const result = await commands.startRecording(inputs);
+
+  if (result !== "Started") {
+    console.error(`Failed to start recording: ${result}`);
+  }
+}
+
+/**
+ * Handle stop command
+ */
+async function handleStopCommand(): Promise<void> {
+  await commands.stopRecording();
+}
+
+/**
+ * Handle pause command
+ */
+async function handlePauseCommand(): Promise<void> {
+  await commands.pauseRecording();
+}
+
+/**
+ * Handle resume command
+ */
+async function handleResumeCommand(): Promise<void> {
+  await commands.resumeRecording();
+}
+
+/**
+ * Handle toggle pause command
+ */
+async function handleTogglePauseCommand(): Promise<void> {
+  await commands.togglePauseRecording();
+}
+
+/**
+ * Handle switch microphone command
+ * Params: label (microphone name/device ID)
+ */
+async function handleSwitchMicCommand(params: Record<string, string>): Promise<void> {
+  const label = params.label || params.device;
+
+  if (!label) {
+    console.error("No microphone label provided");
+    return;
+  }
+
+  await commands.setMicInput(label);
+}
+
+/**
+ * Handle switch camera command
+ * Params: id (camera device ID)
+ */
+async function handleSwitchCameraCommand(params: Record<string, string>): Promise<void> {
+  const id = params.id || params.device;
+
+  if (!id) {
+    console.error("No camera ID provided");
+    return;
+  }
+
+  await commands.setCameraInput(id, true);
+}
+
+/**
+ * Initialize deep link command listener
+ * Returns unsubscribe function
+ */
+export async function initDeepLinkCommands(): Promise<() => void> {
+  console.log("Initializing deep link commands...");
+
+  const unsubscribe = await onOpenUrl(async (urls) => {
+    for (const url of urls) {
+      const command = parseDeepLinkCommand(url);
+
+      if (command) {
+        try {
+          await executeDeepLinkCommand(command);
+        } catch (error) {
+          console.error(`Failed to execute command from ${url}:`, error);
+        }
+      }
+    }
+  });
+
+  return unsubscribe;
+}
+
+/**
+ * Generate deep link URL for a command
+ */
+export function generateDeepLink(
+  action: DeepLinkCommand["action"],
+  params?: Record<string, string>
+): string {
+  const url = new URL(`cap://${action}`);
+
+  if (params) {
+    Object.entries(params).forEach(([key, value]) => {
+      url.searchParams.set(key, value);
+    });
+  }
+
+  return url.toString();
+}
+
+// Export convenience functions for generating deep links
+export const deepLinks = {
+  record: (params?: { mode?: RecordingMode; camera?: string; microphone?: string }) =>
+    generateDeepLink("record", params as Record<string, string>),
+  stop: () => generateDeepLink("stop"),
+  pause: () => generateDeepLink("pause"),
+  resume: () => generateDeepLink("resume"),
+  togglePause: () => generateDeepLink("toggle-pause"),
+  switchMic: (label: string) => generateDeepLink("switch-mic", { label }),
+  switchCamera: (id: string) => generateDeepLink("switch-camera", { id }),
+};

extensions/raycast-cap/README.md

@@ -0,0 +1,49 @@
+# Cap Raycast Extension
+
+Control Cap screen recording from Raycast.
+
+## Features
+
+- **Start Recording** - Start a new screen recording instantly
+- **Stop Recording** - Stop the current recording
+- **Pause Recording** - Pause the recording
+- **Resume Recording** - Resume a paused recording
+- **Toggle Pause** - Toggle between pause and resume
+- **Switch Microphone** - Change to a different microphone input
+- **Switch Camera** - Change to a different camera input
+
+## Installation
+
+1. Make sure you have [Raycast](https://raycast.com/) installed
+2. Install the Cap extension from the Raycast Store
+3. Ensure [Cap](https://cap.so) is installed on your Mac
+
+## Deep Link Protocol
+
+This extension uses Cap's deep link protocol to control the app:
+
+- `cap://record` - Start recording
+- `cap://stop` - Stop recording
+- `cap://pause` - Pause recording
+- `cap://resume` - Resume recording
+- `cap://toggle-pause` - Toggle pause state
+- `cap://switch-mic?label=<id>` - Switch microphone
+- `cap://switch-camera?id=<id>` - Switch camera
+
+## Requirements
+
+- macOS 11.0 or later
+- Cap app installed
+- Raycast v1.50.0 or later
+
+## Development
+
+```bash
+cd extensions/raycast-cap
+npm install
+npm run dev
+```
+
+## License
+
+MIT

extensions/raycast-cap/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "cap",
+  "title": "Cap",
+  "description": "Control Cap screen recording from Raycast",
+  "icon": "cap-icon.png",
+  "author": "divol89",
+  "categories": ["Productivity", "Media"],
+  "license": "MIT",
+  "commands": [
+    {
+      "name": "start-recording",
+      "title": "Start Recording",
+      "description": "Start a new screen recording",
+      "mode": "no-view"
+    },
+    {
+      "name": "stop-recording",
+      "title": "Stop Recording",
+      "description": "Stop the current recording",
+      "mode": "no-view"
+    },
+    {
+      "name": "pause-recording",
+      "title": "Pause Recording",
+      "description": "Pause the current recording",
+      "mode": "no-view"
+    },
+    {
+      "name": "resume-recording",
+      "title": "Resume Recording",
+      "description": "Resume the paused recording",
+      "mode": "no-view"
+    },
+    {
+      "name": "toggle-pause",
+      "title": "Toggle Pause",
+      "description": "Toggle pause/resume recording",
+      "mode": "no-view"
+    },
+    {
+      "name": "switch-microphone",
+      "title": "Switch Microphone",
+      "description": "Switch to a different microphone",
+      "mode": "view"
+    },
+    {
+      "name": "switch-camera",
+      "title": "Switch Camera",
+      "description": "Switch to a different camera",
+      "mode": "view"
+    }
+  ],
+  "dependencies": {
+    "@raycast/api": "^1.64.0",
+    "@raycast/utils": "^1.10.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.8.10",
+    "typescript": "^5.2.2"
+  },
+  "scripts": {
+    "build": "ray build -e dist",
+    "dev": "ray develop",
+    "fix-lint": "ray fix-lint",
+    "lint": "ray lint"
+  }
+}

extensions/raycast-cap/src/pause-recording.ts

@@ -0,0 +1,19 @@
+import { showToast, Toast } from "@raycast/api";
+import { openDeepLink, generateDeepLink } from "./utils";
+
+export default async function Command() {
+  try {
+    await openDeepLink(generateDeepLink("pause"));
+
+    await showToast({
+      style: Toast.Style.Success,
+      title: "Paused Recording",
+    });
+  } catch (error) {
+    await showToast({
+      style: Toast.Style.Failure,
+      title: "Failed to Pause Recording",
+      message: String(error),
+    });
+  }
+}