Merge branch 'main' into feat/editor-transcription-export

Author: richiemcilroy

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

@@ -1,6 +1,7 @@
 import { useQueryClient } from "@tanstack/solid-query";
 import { getCurrentWindow } from "@tauri-apps/api/window";
 import { devicesSnapshot } from "~/utils/devices";
+import { requestAndVerifyPermission } from "~/utils/os-permissions";
 import { commands, type OSPermissionStatus } from "~/utils/tauri";
 
 export default function useRequestPermission() {
@@ -11,22 +12,10 @@ export default function useRequestPermission() {
 		currentStatus?: OSPermissionStatus,
 	) {
 		try {
-			if (currentStatus === "denied") {
-				await commands.openPermissionSettings(type);
-				return;
-			}
-
 			const window = getCurrentWindow();
 			await window.setAlwaysOnTop(false);
 			try {
-				await commands.requestPermission(type);
-
-				const check = await commands.doPermissionsCheck(false);
-				const status = type === "camera" ? check.camera : check.microphone;
-
-				if (status !== "granted") {
-					await commands.openPermissionSettings(type);
-				}
+				await requestAndVerifyPermission(commands, type, currentStatus);
 			} finally {
 				await window.setAlwaysOnTop(true);
 			}

apps/desktop/src/routes/(window-chrome)/new-main/useRequestPermission.ts

@@ -18,6 +18,10 @@ import {
 } from "solid-js";
 import { createStore } from "solid-js/store";
 import { generalSettingsStore } from "~/store";
+import {
+	isPermissionGranted as isPermitted,
+	requestAndVerifyPermission,
+} from "~/utils/os-permissions";
 import {
 	commands,
 	type OSPermission,
@@ -108,10 +112,6 @@ const modes: ModeDetail[] = [
 	},
 ];
 
-function isPermitted(status?: OSPermissionStatus): boolean {
-	return status === "granted" || status === "notNeeded";
-}
-
 type SetupPermission = {
 	name: string;
 	key: OSPermission;
@@ -2001,19 +2001,16 @@ function PermissionsStep(props: {
 		if (requestingPermission()) return;
 		setRequestingPermission(true);
 		try {
-			await commands.requestPermission(permission);
+			const status = check()?.[permission] as OSPermissionStatus | undefined;
 			setInitialCheck(false);
-			const result = await commands.doPermissionsCheck(false);
-			setCheck(result as unknown as Record<string, OSPermissionStatus>);
-			const notYetPermitted =
-				(permission === "screenRecording" &&
-					!isPermitted(result.screenRecording)) ||
-				(permission === "accessibility" && !isPermitted(result.accessibility));
-			if (notYetPermitted) {
-				await commands.openPermissionSettings(permission);
-				if (permission === "screenRecording") {
-					await maybePromptRestartForScreenRecording();
-				}
+			const result = await requestAndVerifyPermission(
+				commands,
+				permission,
+				status,
+			);
+			setCheck(result.check as unknown as Record<string, OSPermissionStatus>);
+			if (result.openedSettings && permission === "screenRecording") {
+				await maybePromptRestartForScreenRecording();
 			}
 		} catch (err) {
 			console.error(`Error requesting permission: ${err}`);

apps/desktop/src/routes/(window-chrome)/onboarding.tsx

@@ -0,0 +1,96 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+	isPermissionGranted,
+	permissionStatusFor,
+	requestAndVerifyPermission,
+} from "~/utils/os-permissions";
+
+describe("os-permissions", () => {
+	it("treats only granted and not-needed statuses as permitted", () => {
+		expect(isPermissionGranted("granted")).toBe(true);
+		expect(isPermissionGranted("notNeeded")).toBe(true);
+		expect(isPermissionGranted("empty")).toBe(false);
+		expect(isPermissionGranted("denied")).toBe(false);
+	});
+
+	it("maps a permission key to the matching OS permission status", () => {
+		const check = {
+			screenRecording: "granted",
+			microphone: "empty",
+			camera: "denied",
+			accessibility: "notNeeded",
+		} as const;
+
+		expect(permissionStatusFor(check, "screenRecording")).toBe("granted");
+		expect(permissionStatusFor(check, "microphone")).toBe("empty");
+		expect(permissionStatusFor(check, "camera")).toBe("denied");
+		expect(permissionStatusFor(check, "accessibility")).toBe("notNeeded");
+	});
+
+	it("does not open settings after a successful permission request", async () => {
+		const client = {
+			requestPermission: vi.fn().mockResolvedValue(undefined),
+			openPermissionSettings: vi.fn().mockResolvedValue(undefined),
+			doPermissionsCheck: vi.fn().mockResolvedValue({
+				screenRecording: "empty",
+				microphone: "granted",
+				camera: "empty",
+				accessibility: "empty",
+			}),
+		};
+
+		const result = await requestAndVerifyPermission(client, "microphone");
+
+		expect(client.requestPermission).toHaveBeenCalledWith("microphone");
+		expect(client.openPermissionSettings).not.toHaveBeenCalled();
+		expect(result.status).toBe("granted");
+		expect(result.openedSettings).toBe(false);
+	});
+
+	it("opens settings when the OS still reports the permission as ungranted", async () => {
+		const client = {
+			requestPermission: vi.fn().mockResolvedValue(undefined),
+			openPermissionSettings: vi.fn().mockResolvedValue(undefined),
+			doPermissionsCheck: vi.fn().mockResolvedValue({
+				screenRecording: "denied",
+				microphone: "empty",
+				camera: "empty",
+				accessibility: "empty",
+			}),
+		};
+
+		const result = await requestAndVerifyPermission(client, "screenRecording");
+
+		expect(client.requestPermission).toHaveBeenCalledWith("screenRecording");
+		expect(client.openPermissionSettings).toHaveBeenCalledWith(
+			"screenRecording",
+		);
+		expect(result.status).toBe("denied");
+		expect(result.openedSettings).toBe(true);
+	});
+
+	it("skips the native request and goes straight to settings for denied permissions", async () => {
+		const client = {
+			requestPermission: vi.fn().mockResolvedValue(undefined),
+			openPermissionSettings: vi.fn().mockResolvedValue(undefined),
+			doPermissionsCheck: vi.fn().mockResolvedValue({
+				screenRecording: "empty",
+				microphone: "empty",
+				camera: "empty",
+				accessibility: "denied",
+			}),
+		};
+
+		const result = await requestAndVerifyPermission(
+			client,
+			"accessibility",
+			"denied",
+		);
+
+		expect(client.requestPermission).not.toHaveBeenCalled();
+		expect(client.openPermissionSettings).toHaveBeenCalledWith("accessibility");
+		expect(result.status).toBe("denied");
+		expect(result.openedSettings).toBe(true);
+	});
+});

apps/desktop/src/utils/os-permissions.test.ts

@@ -0,0 +1,74 @@
+import type {
+	OSPermission,
+	OSPermissionStatus,
+	OSPermissionsCheck,
+} from "~/utils/tauri";
+
+export function isPermissionGranted(status?: OSPermissionStatus): boolean {
+	return status === "granted" || status === "notNeeded";
+}
+
+export function permissionStatusFor(
+	check: OSPermissionsCheck,
+	permission: OSPermission,
+): OSPermissionStatus {
+	switch (permission) {
+		case "screenRecording":
+			return check.screenRecording;
+		case "microphone":
+			return check.microphone;
+		case "camera":
+			return check.camera;
+		case "accessibility":
+			return check.accessibility;
+	}
+}
+
+type PermissionClient = {
+	requestPermission: (permission: OSPermission) => Promise<void>;
+	openPermissionSettings: (permission: OSPermission) => Promise<void>;
+	doPermissionsCheck: (initialCheck: boolean) => Promise<OSPermissionsCheck>;
+};
+
+export type PermissionRequestResult = {
+	check: OSPermissionsCheck;
+	status: OSPermissionStatus;
+	openedSettings: boolean;
+};
+
+export async function requestAndVerifyPermission(
+	client: PermissionClient,
+	permission: OSPermission,
+	currentStatus?: OSPermissionStatus,
+): Promise<PermissionRequestResult> {
+	if (currentStatus === "denied") {
+		await client.openPermissionSettings(permission);
+		const check = await client.doPermissionsCheck(false);
+		return {
+			check,
+			status: permissionStatusFor(check, permission),
+			openedSettings: true,
+		};
+	}
+
+	await client.requestPermission(permission);
+
+	const check = await client.doPermissionsCheck(false);
+	const status = permissionStatusFor(check, permission);
+
+	if (isPermissionGranted(status)) {
+		return {
+			check,
+			status,
+			openedSettings: false,
+		};
+	}
+
+	await client.openPermissionSettings(permission);
+
+	return {
+		check,
+		status,
+		openedSettings: true,
+	};
+}