Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.
TypeScript cross-platformelectronffmpegopen-sourceproduct-demorustscreen-capturescreen-recorderscreen-recordingscreen-studioscreencastspeech-to-texttypescriptvideo-editingvideo-editorwaylandwgpuwhisper
feat(macos): gather every permission in a first-run permissions window
Etienne Lescot366759cd8339
diff --git a/electron/electron-env.d.ts b/electron/electron-env.d.tsindex 826e28e8d..3bf20d40e 100644--- a/electron/electron-env.d.ts+++ b/electron/electron-env.d.ts@@ -40,12 +40,6 @@ interface Window {openSourceSelector: () => Promise<{opened: boolean;reason?: string;- access?: {- success: boolean;- granted: boolean;- status: string;- error?: string;- };}>;openNotes: () => Promise<{opened: boolean;@@ -77,12 +71,14 @@ interface Window {status: string;error?: string;}>;- requestScreenAccess: () => Promise<{- success: boolean;- granted: boolean;- status: string;- error?: string;- }>;+ /** macOS privacy permissions; see electron/permissions/macPermissions.ts. */+ permissions: {+ get: () => Promise<import("./permissions/macPermissions").PermissionsSnapshot>;+ request: (kind: import("./permissions/macPermissions").PermissionKind) => Promise<void>;+ openSettings: (kind: import("./permissions/macPermissions").PermissionKind) => Promise<void>;+ relaunch: () => Promise<void>;+ close: () => Promise<void>;+ };requestNativeMacCursorAccess: () => Promise<{success: boolean;granted: boolean;diff --git a/electron/ipc/handlers.ts b/electron/ipc/handlers.tsindex 17574ffa9..a7d1b25cb 100644--- a/electron/ipc/handlers.ts+++ b/electron/ipc/handlers.ts@@ -83,6 +83,7 @@ import {import { findPipeWireCursorHelperPath } from "../native-bridge/cursor/recording/pipeWireCursorRecordingSession";import type { CursorRecordingSession } from "../native-bridge/cursor/recording/session";import { toHelperRect } from "../native-bridge/helperCoordinates";+import { getMacPermissions, showPermissionsWindow } from "../permissions";import { scoreDeviceNameMatch } from "../recording/deviceNameMatching";import {describeSalvagedTake,@@ -1864,43 +1865,6 @@ export function registerIpcHandlers(const sameSelectedSource = (left: SelectedSource | null, right: SelectedSource | null) =>left?.id === right?.id && left?.name === right?.name && left?.display_id === right?.display_id;- async function requestScreenAccess() {- if (process.platform !== "darwin") {- return { success: true, granted: true, status: "granted" };- }-- try {- const status = systemPreferences.getMediaAccessStatus("screen");- if (status === "granted") {- return { success: true, granted: true, status };- }-- // Screen recording has no askForMediaAccess equivalent, so trigger the- // TCC prompt without opening OpenScreen's source selector above it.- if (status === "not-determined") {- const mainWin = getMainWindow();- if (mainWin && !mainWin.isDestroyed()) {- if (!mainWin.isVisible()) {- mainWin.show();- }- mainWin.focus();- }- app.focus({ steal: true });- desktopCapturer- .getSources({ types: ["screen"], thumbnailSize: { width: 1, height: 1 } })- .catch(() => {- // Permission probing failure is reported by the explicit status check below.- });- return { success: true, granted: false, status: "not-determined" };- }-- return { success: true, granted: false, status };- } catch (error) {- console.error("Failed to request screen access:", error);- return { success: false, granted: false, status: "unknown", error: String(error) };- }- }-ipcMain.handle("get-sources", async (_, opts) => {// desktopCapturer.getSources can never settle where the GL stack cannot be// reached -- a container, a CI runner, a host whose ANGLE fails to@@ -2129,10 +2093,6 @@ export function registerIpcHandlers(}});- ipcMain.handle("request-screen-access", async () => {- return requestScreenAccess();- });-ipcMain.handle("request-native-mac-cursor-access", async () => {const access = await requestMacCursorAccessibilityAccess();@@ -2154,26 +2114,12 @@ export function registerIpcHandlers(return access;}- const mainWin = getMainWindow();- const detail =- "Allow OpenScreen under System Settings → Privacy & Security → Accessibility, then press record again to start the countdown.";- const messageOptions = {- type: "warning",- buttons: ["Open Accessibility Settings", "Cancel"],- defaultId: 0,- cancelId: 1,- message: "Accessibility access is required for the editable cursor",- detail,- } satisfies Electron.MessageBoxOptions;- const result =- mainWin && !mainWin.isDestroyed()- ? await dialog.showMessageBox(mainWin, messageOptions)- : await dialog.showMessageBox(messageOptions);- if (result.response === 0) {- await shell.openExternal(- "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility",- );- }+ // The helper that answered has just raised macOS' own Accessibility prompt on+ // its way up, so the window must offer System Settings, not a second prompt. It+ // explains what the grant is for and tracks it live, where a message box could+ // only say "go to System Settings" in English.+ getMacPermissions().noteRequested("accessibility");+ showPermissionsWindow();}return access;@@ -2193,34 +2139,16 @@ export function registerIpcHandlers(return { opened: false, reason: "portal-owns-selection" };}- const access = await requestScreenAccess();- if (!access.granted) {- if (process.platform === "darwin" && access.status !== "not-determined") {- const mainWin = getMainWindow();- const messageOptions = {- type: "warning",- buttons: ["Open System Settings", "Cancel"],- defaultId: 0,- cancelId: 1,- message: "Screen Recording permission is required",- detail:- "Allow OpenScreen in macOS System Settings, then come back and choose a screen or window.",- } satisfies Electron.MessageBoxOptions;- const result =- mainWin && !mainWin.isDestroyed()- ? await dialog.showMessageBox(mainWin, messageOptions)- : await dialog.showMessageBox(messageOptions);- if (result.response === 0) {- await shell.openExternal(- "x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture",- );- }+ // Chromium's picker can only list sources once THIS process can capture, which on+ // macOS means granted, and granted before launch: the app's own read is cached for+ // the life of the process. Anything short of that belongs in the permissions+ // window, which says what is missing and offers the relaunch when that is all.+ if (process.platform === "darwin") {+ const permissions = await getMacPermissions().read();+ if (permissions.screen !== "granted" || permissions.screenRequiresRelaunch) {+ showPermissionsWindow();+ return { opened: false, reason: "screen-access-required" };}- return {- opened: false,- reason: "screen-access-required",- access,- };}const sourceSelectorWin = getSourceSelectorWindow();diff --git a/electron/main.ts b/electron/main.tsindex c01cfdfba..64ace0cb5 100644--- a/electron/main.ts+++ b/electron/main.ts@@ -12,7 +12,6 @@ import {net,session,shell,- systemPreferences,Tray,} from "electron";import { ShortcutBinding } from "../src/lib/shortcuts";@@ -60,6 +59,11 @@ import {registerIpcHandlers,} from "./ipc/handlers";import { installMainProcessErrorGuards } from "./main-process-errors";+import {+ registerPermissionsIpc,+ showPermissionsWindow,+ showPermissionsWindowIfNeeded,+} from "./permissions";import { registerSttIpc, shutdownStt } from "./stt";import { checkLatestRelease } from "./update-checker";import { loadUpdateMode, saveUpdateMode } from "./update-settings";@@ -231,6 +235,10 @@ function setupApplicationMenu() {role: "about",label: mainT("common", "actions.about") || "About OpenScreen",},+ {+ label: mainT("common", "actions.permissions") || "Permissions…",+ click: showPermissionsWindow,+ },{ type: "separator" as const },{label: mainT("common", "actions.saveDiagnostics") || "Save Diagnostics",@@ -923,6 +931,14 @@ function updateTrayMenu(recording: boolean = false) {label: mainT("common", "actions.saveDiagnostics") || "Save Diagnostics",click: runSaveDiagnostics,},+ ...(isMac+ ? [+ {+ label: mainT("common", "actions.permissions") || "Permissions…",+ click: showPermissionsWindow,+ },+ ]+ : []),{ type: "separator" as const },{label: mainT("common", "actions.quit") || "Quit",@@ -1182,25 +1198,11 @@ appReady?.then(async () => {});}- // Request mic permission now. Screen Recording is requested lazily from the- // source-picker action so its prompt isn't hidden behind the selector window.- //- // NOT awaited, on purpose. `askForMediaAccess` resolves only once the user- // answers the modal TCC prompt, and `createWindow()` is 70 lines below this in- // the same async block — so on a Mac where the microphone is still- // `not-determined` (every first run, and every fresh dev machine) the app- // showed a permission dialog with NO window behind it and created the HUD only- // after it was dismissed. Nothing between here and `createWindow()` needs the- // answer: the recorder re-checks the status when the user actually arms the mic.- if (process.platform === "darwin") {- const micStatus = systemPreferences.getMediaAccessStatus("microphone");- if (micStatus !== "granted") {- systemPreferences- .askForMediaAccess("microphone")- .then((granted) => console.info(`[permissions] microphone granted=${granted}`))- .catch((error) => console.warn("[permissions] microphone request failed:", error));- }- }+ // No permission is requested at launch. Screen Recording, Accessibility, the microphone+ // and the camera are all gathered in the permissions window (electron/permissions),+ // opened below when recording cannot work yet; the microphone and camera are also+ // requested at the moment a take first uses them.+ registerPermissionsIpc();ipcMain.on("hud-overlay-close", () => {app.quit();@@ -1332,4 +1334,7 @@ appReady?.then(async () => {}createWindow();+ void showPermissionsWindowIfNeeded().catch((error) =>+ console.warn("[permissions] could not read the permissions at launch:", error),+ );});diff --git a/electron/native-bridge/screen/macScreenAccess.test.ts b/electron/native-bridge/screen/macScreenAccess.test.tsnew file mode 100644index 000000000..d8afe447f--- /dev/null+++ b/electron/native-bridge/screen/macScreenAccess.test.ts@@ -0,0 +1,196 @@+import { EventEmitter } from "node:events";+import { PassThrough } from "node:stream";+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";++/**+ * The cast on `actual` is written out in each factory rather than shared in a helper:+ * `vi.mock` calls are HOISTED above every top-level statement, so a module-scope helper+ * is still in its temporal dead zone when the factory runs.+ */+type WithDefault = { default?: Record<string, unknown> };++vi.mock("node:child_process", async (importOriginal) => {+ const actual = await importOriginal<typeof import("node:child_process")>();+ const spawn = vi.fn();+ return { ...actual, spawn, default: { ...((actual as WithDefault).default ?? {}), spawn } };+});++const mocks = vi.hoisted(() => ({ accessSync: vi.fn() }));++vi.mock("node:fs", async (importOriginal) => {+ const actual = await importOriginal<typeof import("node:fs")>();+ // No helper binary exists in a test checkout; by default pretend the first candidate+ // path is executable so path resolution is not what is under test.+ return {+ ...actual,+ accessSync: mocks.accessSync,+ default: { ...((actual as WithDefault).default ?? {}), accessSync: mocks.accessSync },+ };+});++import { spawn } from "node:child_process";+import { isMacScreenProbeUnavailable, readMacScreenCaptureAccess } from "./macScreenAccess";++/** Minimal stand-in for the helper: stdio pipes plus kill bookkeeping. */+class FakeHelper extends EventEmitter {+ stdout = new PassThrough();+ stderr = new PassThrough();+ killed = false;++ kill() {+ this.killed = true;+ return true;+ }++ /** Feeds one NDJSON line, the way the real helper emits them. */+ emitEvent(event: Record<string, unknown>) {+ this.stdout.write(`${JSON.stringify(event)}\n`);+ }+}++const spawnMock = vi.mocked(spawn);+let helper: FakeHelper;+let originalPlatform: PropertyDescriptor | undefined;++beforeEach(() => {+ originalPlatform = Object.getOwnPropertyDescriptor(process, "platform");+ Object.defineProperty(process, "platform", { value: "darwin", configurable: true });+ helper = new FakeHelper();+ spawnMock.mockReset();+ spawnMock.mockReturnValue(helper as unknown as ReturnType<typeof spawn>);+ mocks.accessSync.mockReset();+});++afterEach(() => {+ if (originalPlatform) {+ Object.defineProperty(process, "platform", originalPlatform);+ }+ vi.restoreAllMocks();+});++/** Lets the spawn listeners attach before the fake helper speaks. */+async function settle<T>(pending: Promise<T>, act: () => void): Promise<T> {+ await Promise.resolve();+ act();+ return pending;+}++describe("readMacScreenCaptureAccess", () => {+ it("grants when the helper reports the permission", async () => {+ const access = await settle(readMacScreenCaptureAccess(), () =>+ helper.emitEvent({ event: "screen-access", granted: true }),+ );++ expect(access).toMatchObject({ success: true, granted: true, status: "granted" });+ });++ it("denies when the helper reports the permission is absent", async () => {+ const access = await settle(readMacScreenCaptureAccess(), () =>+ helper.emitEvent({ event: "screen-access", granted: false }),+ );++ expect(access).toMatchObject({ success: true, granted: false, status: "denied" });+ });++ it("spawns the probe flag and never a recording request", async () => {+ await settle(readMacScreenCaptureAccess(), () =>+ helper.emitEvent({ event: "screen-access", granted: true }),+ );++ expect(spawnMock).toHaveBeenCalledTimes(1);+ expect(spawnMock.mock.calls[0]?.[1]).toEqual(["--screen-access-status"]);+ });++ it("reads a fresh answer per call, which is the point of the child process", async () => {+ // The main process cannot do this: CGPreflightScreenCaptureAccess caches its+ // result for the life of the caller, so a grant made while the app runs is+ // invisible to it. Every call here is a new process, so the second read sees+ // the grant the first one missed.+ const first = await settle(readMacScreenCaptureAccess(), () =>+ helper.emitEvent({ event: "screen-access", granted: false }),+ );+ helper = new FakeHelper();+ spawnMock.mockReturnValue(helper as unknown as ReturnType<typeof spawn>);+ const second = await settle(readMacScreenCaptureAccess(), () =>+ helper.emitEvent({ event: "screen-access", granted: true }),+ );++ expect(first.granted).toBe(false);+ expect(second.granted).toBe(true);+ expect(spawnMock).toHaveBeenCalledTimes(2);+ });++ it("reports missing-helper rather than a refusal when no binary is installed", async () => {+ mocks.accessSync.mockImplementation(() => {+ throw new Error("ENOENT");+ });++ const access = await readMacScreenCaptureAccess();++ expect(access).toMatchObject({ granted: false, status: "missing-helper" });+ expect(isMacScreenProbeUnavailable(access.status)).toBe(true);+ expect(spawnMock).not.toHaveBeenCalled();+ });++ it("reads the answer even when the helper dies in the same tick", async () => {+ // The helper prints one line and exits immediately, so the process-death event can+ // land before stdout has been drained. Racing it away would report a good answer+ // as a dead helper on a machine that is merely fast.+ const access = await settle(readMacScreenCaptureAccess(), () => {+ helper.emitEvent({ event: "screen-access", granted: true });+ helper.emit("close", 0, null);+ });++ expect(access).toMatchObject({ granted: true, status: "granted" });+ });++ it("reports exited rather than a refusal when an older helper rejects the flag", async () => {+ // A build predating the probe mode answers `invalidArguments` and exits 1.+ // Calling that a denial would tell a user with a working grant to go and+ // re-grant it.+ const access = await settle(readMacScreenCaptureAccess(), () => helper.emit("close", 1, null));++ expect(access).toMatchObject({ granted: false, status: "exited" });+ expect(isMacScreenProbeUnavailable(access.status)).toBe(true);+ });++ it("reports error when the helper cannot be launched at all", async () => {+ const access = await settle(readMacScreenCaptureAccess(), () =>+ helper.emit("error", new Error("EACCES")),+ );++ expect(access).toMatchObject({ granted: false, status: "error", error: "EACCES" });+ expect(isMacScreenProbeUnavailable(access.status)).toBe(true);+ });++ it("reports timeout and kills the helper when it never answers", async () => {+ // A hung helper must neither stall the caller nor be read as a refusal, and must+ // not outlive the read that spawned it.+ vi.useFakeTimers();+ try {+ const pending = readMacScreenCaptureAccess();+ await vi.advanceTimersByTimeAsync(3_000);+ const access = await pending;++ expect(access).toMatchObject({+ success: false,+ granted: false,+ status: "timeout",+ error: "Timed out reading the macOS screen recording permission",+ });+ expect(isMacScreenProbeUnavailable(access.status)).toBe(true);+ expect(helper.killed).toBe(true);+ } finally {+ vi.useRealTimers();+ }+ });++ it("answers granted off-darwin without spawning anything", async () => {+ Object.defineProperty(process, "platform", { value: "win32", configurable: true });++ const access = await readMacScreenCaptureAccess();++ expect(access).toMatchObject({ granted: true, status: "granted" });+ expect(spawnMock).not.toHaveBeenCalled();+ });+});diff --git a/electron/native-bridge/screen/macScreenAccess.ts b/electron/native-bridge/screen/macScreenAccess.tsnew file mode 100644index 000000000..f167048a3--- /dev/null+++ b/electron/native-bridge/screen/macScreenAccess.ts@@ -0,0 +1,187 @@+import { spawn } from "node:child_process";+import { accessSync, constants as fsConstants } from "node:fs";+import path from "node:path";++/**+ * Reading macOS' Screen Recording grant from a short-lived child process.+ *+ * `CGPreflightScreenCaptureAccess()` caches its answer for the life of the process+ * that calls it. Once it has answered false it answers false forever, whatever the+ * user does in System Settings afterwards -- Apple's own guidance is to relaunch.+ * Electron's `systemPreferences.getMediaAccessStatus("screen")` is that same+ * function (Chromium's `IsScreenCaptureAllowed()` in `ui/base/cocoa/permissions_utils.mm`),+ * so the app's main process holds one stale bool for its entire run.+ *+ * That is the whole reason this module exists. The helper is spawned fresh for every+ * read, so every read is the current answer, and a grant the user makes while the app+ * is running becomes observable without a restart.+ *+ * The prompt is NOT raised here. It stays in the main process, where Chromium raises+ * it through the app bundle, so TCC records the grant against the app's designated+ * requirement rather than against a bare child binary.+ */++const HELPER_NAME = "openscreen-screencapturekit-helper";++/** Kept in step with `screenAccessStatusFlag` in ScreenCaptureRecorder.swift. */+const SCREEN_ACCESS_STATUS_FLAG = "--screen-access-status";++/**+ * The helper prints one line and exits, so this bounds a hung spawn rather than a+ * slow answer. Shorter than the cursor helper's budget because nothing here waits+ * on a window server handshake.+ */+const PROBE_TIMEOUT_MS = 3_000;++/**+ * Why `denied` is the only status that means "the user said no".+ *+ * The other four mean the helper never got to answer -- absent from the build, killed+ * by the loader, crashed, or hung. Treating those as a refusal is what would put the+ * "grant Screen Recording" dialog in front of a user whose permission is fine, which is+ * the same failure the cursor helper's `missing-helper` split exists to prevent (#515).+ */+export type MacScreenAccessStatus =+ | "granted"+ | "denied"+ | "missing-helper"+ | "error"+ | "exited"+ | "timeout";++export interface MacScreenAccessResult {+ success: boolean;+ granted: boolean;+ status: MacScreenAccessStatus;+ error?: string;+}++/** True when the probe never got far enough to answer the permission question. */+export function isMacScreenProbeUnavailable(status: MacScreenAccessStatus) {+ return (+ status === "missing-helper" || status === "error" || status === "exited" || status === "timeout"+ );+}++function helperCandidates() {+ const envPath = process.env.OPENSCREEN_SCK_CAPTURE_EXE?.trim();+ const appRoot = process.env.APP_ROOT ? path.resolve(process.env.APP_ROOT) : process.cwd();+ const archTag = process.arch === "arm64" ? "darwin-arm64" : "darwin-x64";+ const resourceRoot =+ typeof process.resourcesPath === "string"+ ? process.resourcesPath+ : path.join(appRoot, "resources");++ return [+ envPath,+ path.join(appRoot, "electron", "native", "screencapturekit", "build", HELPER_NAME),+ path.join(appRoot, "electron", "native", "bin", archTag, HELPER_NAME),+ path.join(resourceRoot, "electron", "native", "bin", archTag, HELPER_NAME),+ ].filter((candidate): candidate is string => Boolean(candidate));+}++export function findMacScreenAccessHelperPath() {+ for (const candidate of helperCandidates()) {+ try {+ accessSync(candidate, fsConstants.X_OK);+ return candidate;+ } catch {+ // Try the next helper location.+ }+ }++ return null;+}++/**+ * Reads the current Screen Recording grant, uncached.+ *+ * Never prompts and never blocks on the user: the helper calls the preflight function+ * only, so this is safe to poll while macOS' own prompt is on screen.+ */+export async function readMacScreenCaptureAccess(): Promise<MacScreenAccessResult> {+ if (process.platform !== "darwin") {+ return { success: true, granted: true, status: "granted" };+ }++ const helperPath = findMacScreenAccessHelperPath();+ if (!helperPath) {+ return { success: true, granted: false, status: "missing-helper" };+ }++ return new Promise<MacScreenAccessResult>((resolve) => {+ const child = spawn(helperPath, [SCREEN_ACCESS_STATUS_FLAG], {+ stdio: ["ignore", "pipe", "pipe"],+ });+ let settled = false;+ let lineBuffer = "";++ const finish = (result: MacScreenAccessResult) => {+ if (settled) {+ return;+ }+ settled = true;+ clearTimeout(timer);+ if (!child.killed) {+ child.kill("SIGTERM");+ }+ resolve(result);+ };++ const timer = setTimeout(() => {+ finish({+ success: false,+ granted: false,+ status: "timeout",+ error: "Timed out reading the macOS screen recording permission",+ });+ }, PROBE_TIMEOUT_MS);++ child.stdout.setEncoding("utf8");+ child.stdout.on("data", (chunk: string) => {+ lineBuffer += chunk;+ const lines = lineBuffer.split(/\r?\n/);+ lineBuffer = lines.pop() ?? "";+ for (const line of lines) {+ const trimmed = line.trim();+ if (!trimmed) {+ continue;+ }+ try {+ const event = JSON.parse(trimmed) as { event?: string; granted?: boolean };+ if (event.event === "screen-access") {+ finish({+ success: true,+ granted: event.granted === true,+ status: event.granted === true ? "granted" : "denied",+ });+ return;+ }+ } catch {+ // Ignore non-JSON helper output.+ }+ }+ });++ child.once("error", (error) => {+ finish({ success: false, granted: false, status: "error", error: error.message });+ });++ // `close`, not `exit`. This helper prints one line and dies, and `exit` can fire+ // before stdout has been drained to the listener above -- which would report a+ // perfectly good answer as a dead helper. `close` waits for the stdio streams.+ //+ // Reaching it at all means the helper ran and said nothing: an older build without+ // the flag, which answers `invalidArguments` and exits 1. Reported as `exited`+ // rather than a refusal, so the caller falls back to the app's own status instead+ // of accusing the user of denying a permission they may well hold.+ child.once("close", (code, signal) => {+ finish({+ success: false,+ granted: false,+ status: "exited",+ error: `macOS screen access probe exited (code=${code}, signal=${signal})`,+ });+ });+ });+}diff --git a/electron/native/README.md b/electron/native/README.mdindex 3a5363530..bd84dd2f5 100644--- a/electron/native/README.md+++ b/electron/native/README.md@@ -9,6 +9,8 @@ macOS native recording will use a ScreenCaptureKit helper with the same process3. The helper owns ScreenCaptureKit/AVFoundation capture, timing, encoding, and muxing.4. Electron persists the resulting media/session manifest and reports helper errors explicitly.+The helper has one non-recording mode: `openscreen-screencapturekit-helper --screen-access-status` prints `{"event":"screen-access","granted":<bool>}` and exits. `CGPreflightScreenCaptureAccess()` caches its answer for the life of the calling process, so Electron's own read can never observe a Screen Recording grant made after launch — a helper spawned per read has no cache to be stale (`electron/native-bridge/screen/macScreenAccess.ts`).+Helper locations:1. `OPENSCREEN_SCK_CAPTURE_EXE`, for local development and diagnostics.diff --git a/electron/native/screencapturekit/Sources/OpenScreenScreenCaptureKitHelper/ScreenCaptureRecorder.swift b/electron/native/screencapturekit/Sources/OpenScreenScreenCaptureKitHelper/ScreenCaptureRecorder.swiftindex 785c4a3a1..8b08e1554 100644--- a/electron/native/screencapturekit/Sources/OpenScreenScreenCaptureKitHelper/ScreenCaptureRecorder.swift+++ b/electron/native/screencapturekit/Sources/OpenScreenScreenCaptureKitHelper/ScreenCaptureRecorder.swift@@ -931,10 +931,35 @@ struct OpenScreenScreenCaptureKitHelper {_ = CGMainDisplayID()}+ /// The flag that turns this helper into a one-shot answer to "may we record the+ /// screen", printed as the usual single JSON line and nothing else.+ private static let screenAccessStatusFlag = "--screen-access-status"+static func main() async {do {initializeCoreGraphicsWindowServerConnection()+ // Answered from a process that exists for one read and then dies, because a FRESH+ // PROCESS is the only place the answer can be trusted.+ // `CGPreflightScreenCaptureAccess()` caches its result for the life of the calling+ // process: once it has answered false it answers false forever, whatever the user+ // does in System Settings afterwards. The app is long-lived, and Chromium's+ // `getMediaAccessStatus("screen")` goes through that same function, so from the+ // first miss until the next relaunch the app cannot observe its own permission+ // being granted. That staleness -- not the missing prompt alone -- is what left+ // the permission unreachable without a restart.+ //+ // Deliberately BEFORE the macOS 13 guard and the request decode below: the question+ // is asked on every macOS the app supports, and answering it needs neither+ // ScreenCaptureKit nor a recording request.+ if CommandLine.arguments.count == 2, CommandLine.arguments[1] == screenAccessStatusFlag {+ emit([+ "event": "screen-access",+ "granted": CGPreflightScreenCaptureAccess(),+ ])+ exit(0)+ }+guard CommandLine.arguments.count == 2 else {throw HelperError.invalidArguments}diff --git a/electron/permissions/index.ts b/electron/permissions/index.tsnew file mode 100644index 000000000..0002df9e8--- /dev/null+++ b/electron/permissions/index.ts@@ -0,0 +1,154 @@+import { readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";+import path from "node:path";+import {+ app,+ type BrowserWindow,+ desktopCapturer,+ ipcMain,+ shell,+ systemPreferences,+} from "electron";+import { readMacScreenCaptureAccess } from "../native-bridge/screen/macScreenAccess";+import { createPermissionsWindow } from "../windows";+import {+ createMacPermissions,+ type MacPermissions,+ type NotedKind,+ type PermissionKind,+ type PermissionsStore,+} from "./macPermissions";++export type { PermissionKind, PermissionsSnapshot } from "./macPermissions";++const STORE_FILE = "permissions.json";++/**+ * The app's own note of which prompts it has raised on this Mac: the one thing macOS+ * will not say. Only ever used to choose between raising a prompt and opening System+ * Settings -- never as the answer to whether a permission is held, which is always+ * read live.+ *+ * A stale note (the user reset TCC with `tccutil`) costs the prompt, and the user gets+ * the System Settings pane instead, which still works. A lost one costs a request macOS+ * silently ignores. Both leave the user with something to act on.+ */+function createFileStore(userData: string): PermissionsStore {+ const file = path.join(userData, STORE_FILE);+ let requested: Partial<Record<NotedKind, string>> = {};+ try {+ const parsed: unknown = JSON.parse(readFileSync(file, "utf8"));+ if (parsed && typeof parsed === "object" && "requested" in parsed) {+ requested = (parsed as { requested: typeof requested }).requested ?? {};+ }+ } catch {+ // Missing or unreadable: nothing has been asked yet.+ }++ return {+ hasRequested: (kind) => typeof requested[kind] === "string",+ markRequested: (kind) => {+ requested = { ...requested, [kind]: new Date().toISOString() };+ const temporary = `${file}.${process.pid}.tmp`;+ try {+ writeFileSync(temporary, `${JSON.stringify({ requested }, null, 2)}\n`, "utf8");+ renameSync(temporary, file);+ } catch (error) {+ // Best effort: the in-memory note still gets the rest of this launch right.+ console.warn("[permissions] failed to persist the request note:", error);+ } finally {+ rmSync(temporary, { force: true });+ }+ },+ };+}++function macosMajor(): number {+ if (process.platform !== "darwin") {+ return 0;+ }+ const major = Number.parseInt(process.getSystemVersion().split(".")[0] ?? "", 10);+ return Number.isFinite(major) ? major : 0;+}++let permissions: MacPermissions | null = null;++export function getMacPermissions(): MacPermissions {+ permissions ??= createMacPermissions({+ platform: process.platform,+ macosMajor: macosMajor(),+ probeScreen: async () => {+ const probe = await readMacScreenCaptureAccess();+ return probe.status === "granted" || probe.status === "denied"+ ? { answered: true, granted: probe.granted }+ : { answered: false };+ },+ appScreenGranted: () => systemPreferences.getMediaAccessStatus("screen") === "granted",+ accessibilityTrusted: (prompt) => systemPreferences.isTrustedAccessibilityClient(prompt),+ mediaStatus: (kind) => systemPreferences.getMediaAccessStatus(kind),+ askForMedia: (kind) => systemPreferences.askForMediaAccess(kind),+ // Raised from THIS process, through Chromium's own call to+ // CGRequestScreenCaptureAccess, so TCC files the grant under the app bundle.+ // The call rejects within milliseconds while the permission is missing, so nothing+ // is learned from awaiting it; the answer is read back from a fresh process.+ raiseScreenPrompt: () => {+ desktopCapturer+ .getSources({ types: ["screen"], thumbnailSize: { width: 1, height: 1 } })+ .catch(() => undefined);+ },+ openExternal: (url) => shell.openExternal(url),+ store: createFileStore(app.getPath("userData")),+ });+ return permissions;+}++let permissionsWindow: BrowserWindow | null = null;++export function showPermissionsWindow(): void {+ if (process.platform !== "darwin") {+ return;+ }+ if (permissionsWindow && !permissionsWindow.isDestroyed()) {+ permissionsWindow.show();+ permissionsWindow.focus();+ return;+ }+ permissionsWindow = createPermissionsWindow();+ permissionsWindow.on("closed", () => {+ permissionsWindow = null;+ });+}++/** Opens the permissions window when recording cannot work yet. For app launch. */+export async function showPermissionsWindowIfNeeded(): Promise<void> {+ // Not in the headless e2e runs either: there is no one to answer, and the probe would+ // hold the window open behind every spec.+ if (process.platform !== "darwin" || process.env["HEADLESS"] === "true") {+ return;+ }+ const snapshot = await getMacPermissions().read();+ if (snapshot.screen !== "granted" || snapshot.screenRequiresRelaunch) {+ showPermissionsWindow();+ }+}++const KINDS: readonly PermissionKind[] = ["screen", "accessibility", "microphone", "camera"];+const isKind = (value: unknown): value is PermissionKind => KINDS.includes(value as PermissionKind);++export function registerPermissionsIpc(): void {+ ipcMain.handle("permissions:get", () => getMacPermissions().read());+ ipcMain.handle("permissions:request", (_event, kind: unknown) =>+ isKind(kind) ? getMacPermissions().request(kind) : undefined,+ );+ ipcMain.handle("permissions:open-settings", (_event, kind: unknown) =>+ isKind(kind) ? getMacPermissions().openSettings(kind) : undefined,+ );+ ipcMain.handle("permissions:relaunch", () => {+ app.relaunch();+ app.quit();+ });+ ipcMain.handle("permissions:close", () => {+ if (permissionsWindow && !permissionsWindow.isDestroyed()) {+ permissionsWindow.close();+ }+ });+}diff --git a/electron/permissions/macPermissions.test.ts b/electron/permissions/macPermissions.test.tsnew file mode 100644index 000000000..426bb3b53--- /dev/null+++ b/electron/permissions/macPermissions.test.ts@@ -0,0 +1,184 @@+import { describe, expect, it, vi } from "vitest";+import {+ createMacPermissions,+ type MacPermissionsDeps,+ type NotedKind,+ permissionSettingsUrl,+ type ScreenProbe,+} from "./macPermissions";++function setup(overrides: Partial<MacPermissionsDeps> = {}) {+ const requested = new Set<NotedKind>();+ const deps: MacPermissionsDeps = {+ platform: "darwin",+ macosMajor: 26,+ probeScreen: vi.fn(async (): Promise<ScreenProbe> => ({ answered: true, granted: false })),+ appScreenGranted: vi.fn(() => false),+ accessibilityTrusted: vi.fn(() => false),+ mediaStatus: vi.fn(() => "not-determined"),+ askForMedia: vi.fn(async () => true),+ raiseScreenPrompt: vi.fn(),+ openExternal: vi.fn(async () => undefined),+ store: {+ hasRequested: (kind) => requested.has(kind),+ markRequested: (kind) => {+ requested.add(kind);+ },+ },+ ...overrides,+ };+ return { deps, requested, permissions: createMacPermissions(deps) };+}++describe("read", () => {+ it("reports a first run as not requested, not as refused", async () => {+ const { permissions } = setup();++ expect(await permissions.read()).toMatchObject({+ supported: true,+ macosMajor: 26,+ screen: "not-requested",+ screenRequiresRelaunch: false,+ accessibility: "not-requested",+ microphone: "not-requested",+ camera: "not-requested",+ });+ });++ it("reports a refusal once the app has asked", async () => {+ const { permissions, requested } = setup();+ requested.add("screen");+ requested.add("accessibility");++ expect(await permissions.read()).toMatchObject({ screen: "denied", accessibility: "denied" });+ });++ it("trusts the fresh-process read over the app's cached one", async () => {+ // The case the helper exists for: granted in System Settings while the app runs.+ const { permissions } = setup({+ probeScreen: async () => ({ answered: true, granted: true }),+ appScreenGranted: () => false,+ });++ expect(await permissions.read()).toMatchObject({+ screen: "granted",+ screenRequiresRelaunch: true,+ });+ });++ it("needs no relaunch when both reads agree on a grant", async () => {+ const { permissions } = setup({+ probeScreen: async () => ({ answered: true, granted: true }),+ appScreenGranted: () => true,+ });++ expect(await permissions.read()).toMatchObject({+ screen: "granted",+ screenRequiresRelaunch: false,+ });+ });++ it("falls back to the app's own read when the helper cannot answer", async () => {+ const granted = setup({+ probeScreen: async () => ({ answered: false }),+ appScreenGranted: () => true,+ });+ const refused = setup({ probeScreen: async () => ({ answered: false }) });++ expect((await granted.permissions.read()).screen).toBe("granted");+ expect((await refused.permissions.read()).screen).toBe("not-requested");+ });++ it("maps the camera and microphone statuses, restricted included", async () => {+ const { permissions } = setup({+ mediaStatus: (kind) => (kind === "microphone" ? "restricted" : "denied"),+ });++ expect(await permissions.read()).toMatchObject({ microphone: "restricted", camera: "denied" });+ });++ it("reads everything as granted off macOS without touching the helper", async () => {+ const { permissions, deps } = setup({ platform: "win32" });++ expect(await permissions.read()).toMatchObject({+ supported: false,+ screen: "granted",+ accessibility: "granted",+ });+ expect(deps.probeScreen).not.toHaveBeenCalled();+ });+});++describe("request", () => {+ it("raises the Screen Recording prompt once, noting it first", async () => {+ const { permissions, deps, requested } = setup();++ await permissions.request("screen");++ expect(requested.has("screen")).toBe(true);+ expect(deps.raiseScreenPrompt).toHaveBeenCalledTimes(1);+ expect(deps.openExternal).not.toHaveBeenCalled();+ });++ it("opens System Settings instead once macOS will not prompt again", async () => {+ const { permissions, deps } = setup();++ await permissions.request("screen");+ await permissions.request("screen");++ expect(deps.raiseScreenPrompt).toHaveBeenCalledTimes(1);+ expect(deps.openExternal).toHaveBeenCalledWith(permissionSettingsUrl("screen"));+ });++ it("prompts for Accessibility the first time and opens its pane after", async () => {+ const { permissions, deps } = setup();++ await permissions.request("accessibility");+ expect(deps.accessibilityTrusted).toHaveBeenCalledWith(true);++ await permissions.request("accessibility");+ expect(deps.openExternal).toHaveBeenCalledWith(permissionSettingsUrl("accessibility"));+ });++ it("asks macOS for the microphone while it is undetermined", async () => {+ const { permissions, deps } = setup();++ await permissions.request("microphone");++ expect(deps.askForMedia).toHaveBeenCalledWith("microphone");+ });++ it("sends a refused camera to its pane", async () => {+ const { permissions, deps } = setup({ mediaStatus: () => "denied" });++ await permissions.request("camera");++ expect(deps.askForMedia).not.toHaveBeenCalled();+ expect(deps.openExternal).toHaveBeenCalledWith(permissionSettingsUrl("camera"));+ });++ it("does nothing for a granted or policy-restricted permission", async () => {+ const { permissions, deps } = setup({+ probeScreen: async () => ({ answered: true, granted: true }),+ mediaStatus: () => "restricted",+ });++ await permissions.request("screen");+ await permissions.request("microphone");++ expect(deps.raiseScreenPrompt).not.toHaveBeenCalled();+ expect(deps.askForMedia).not.toHaveBeenCalled();+ expect(deps.openExternal).not.toHaveBeenCalled();+ });+});++describe("permissionSettingsUrl", () => {+ it("uses the pane anchors that open on every supported macOS", () => {+ expect(permissionSettingsUrl("screen")).toBe(+ "x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture",+ );+ expect(permissionSettingsUrl("accessibility")).toBe(+ "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility",+ );+ });+});diff --git a/electron/permissions/macPermissions.ts b/electron/permissions/macPermissions.tsnew file mode 100644index 000000000..b86fd4cf6--- /dev/null+++ b/electron/permissions/macPermissions.ts@@ -0,0 +1,201 @@+/**+ * The macOS privacy permissions OpenScreen uses, read and requested in one place.+ *+ * Four permissions, and only one of them is required:+ *+ * - `screen`: Screen & System Audio Recording. Required. It also covers system audio,+ * because that is captured through ScreenCaptureKit rather than a Core Audio tap.+ * - `accessibility`: recommended. The cursor helper needs it to tell pointer and text+ * cursors apart; without it recording still works, with plainer cursor telemetry.+ * - `microphone` and `camera`: optional, and still requested at the moment of use when+ * the user skipped them here.+ *+ * Screen Recording is the awkward one, for two reasons macOS gives no API around:+ *+ * 1. `CGPreflightScreenCaptureAccess()` caches its answer for the life of the calling+ * process, and Electron's `getMediaAccessStatus("screen")` is that same call. A grant+ * made while the app runs is invisible to the app's own read, so the live status is+ * read from a helper spawned fresh for every read (`macScreenAccess.ts`).+ * 2. That read is a bool: "never asked" and "refused" are the same `false`. macOS shows+ * its prompt once per decision and ignores every later request, so the app keeps its+ * own note of having asked -- the only way to know whether a request can still raise+ * a prompt or has to send the user to System Settings instead.+ *+ * Accessibility has the same bool-only read, and the same note is kept for it.+ */++export type PermissionKind = "screen" | "accessibility" | "microphone" | "camera";++/**+ * - `not-requested`: nothing has been asked yet, so a request can raise macOS' prompt.+ * - `denied`: asked and not granted. Only System Settings can change it now.+ * - `restricted`: forbidden by policy (MDM, Screen Time). Nothing the user can do here.+ */+export type PermissionStatus = "granted" | "not-requested" | "denied" | "restricted";++export interface PermissionsSnapshot {+ /** False off macOS, where none of this applies and every permission reads granted. */+ supported: boolean;+ /** macOS major version (13, 14, 15, 26...), 0 when unknown or off macOS. */+ macosMajor: number;+ screen: PermissionStatus;+ /**+ * Screen Recording is granted, but this process still reads its cached refusal, so the+ * parts of the app that go through Chromium (the source picker) cannot use it until the+ * app is relaunched.+ */+ screenRequiresRelaunch: boolean;+ accessibility: PermissionStatus;+ microphone: PermissionStatus;+ camera: PermissionStatus;+}++/** What a fresh-process read of the Screen Recording grant answered. */+export type ScreenProbe = { answered: true; granted: boolean } | { answered: false };++export type NotedKind = "screen" | "accessibility";++export interface PermissionsStore {+ hasRequested(kind: NotedKind): boolean;+ markRequested(kind: NotedKind): void;+}++export interface MacPermissionsDeps {+ platform: NodeJS.Platform;+ macosMajor: number;+ probeScreen(): Promise<ScreenProbe>;+ /** The app's own, per-process cached Screen Recording read. */+ appScreenGranted(): boolean;+ /** `isTrustedAccessibilityClient`: `prompt` raises macOS' prompt as a side effect. */+ accessibilityTrusted(prompt: boolean): boolean;+ /** `getMediaAccessStatus` for the microphone or camera. */+ mediaStatus(kind: "microphone" | "camera"): string;+ askForMedia(kind: "microphone" | "camera"): Promise<boolean>;+ /** Raises macOS' Screen Recording prompt from the app's own process. */+ raiseScreenPrompt(): void;+ openExternal(url: string): Promise<void>;+ store: PermissionsStore;+}++/**+ * The legacy `com.apple.preference.security` form opens the right pane on every version+ * from 13 to 26. The `com.apple.settings.PrivacySecurity.extension` form that macOS 26+ * uses itself is unconfirmed on 13.+ */+const SETTINGS_ANCHOR: Record<PermissionKind, string> = {+ screen: "Privacy_ScreenCapture",+ accessibility: "Privacy_Accessibility",+ microphone: "Privacy_Microphone",+ camera: "Privacy_Camera",+};++export function permissionSettingsUrl(kind: PermissionKind): string {+ return `x-apple.systempreferences:com.apple.preference.security?${SETTINGS_ANCHOR[kind]}`;+}++function mediaPermissionStatus(status: string): PermissionStatus {+ switch (status) {+ case "granted":+ return "granted";+ case "not-determined":+ return "not-requested";+ case "restricted":+ return "restricted";+ default:+ return "denied";+ }+}++const OFF_MACOS: PermissionsSnapshot = {+ supported: false,+ macosMajor: 0,+ screen: "granted",+ screenRequiresRelaunch: false,+ accessibility: "granted",+ microphone: "granted",+ camera: "granted",+};++export function createMacPermissions(deps: MacPermissionsDeps) {+ const notedStatus = (kind: NotedKind): PermissionStatus =>+ deps.store.hasRequested(kind) ? "denied" : "not-requested";++ async function readScreen(): Promise<{ status: PermissionStatus; requiresRelaunch: boolean }> {+ const appGranted = deps.appScreenGranted();+ const probe = await deps.probeScreen();+ // A helper that could not answer (absent from the build, crashed, hung) says nothing+ // about the permission, so this falls back to the app's own read: stale at worst,+ // which is all any build had before the helper.+ const granted = probe.answered ? probe.granted : appGranted;+ if (!granted) {+ return { status: notedStatus("screen"), requiresRelaunch: false };+ }+ return { status: "granted", requiresRelaunch: !appGranted };+ }++ async function read(): Promise<PermissionsSnapshot> {+ if (deps.platform !== "darwin") {+ return OFF_MACOS;+ }++ const screen = await readScreen();+ return {+ supported: true,+ macosMajor: deps.macosMajor,+ screen: screen.status,+ screenRequiresRelaunch: screen.requiresRelaunch,+ accessibility: deps.accessibilityTrusted(false) ? "granted" : notedStatus("accessibility"),+ microphone: mediaPermissionStatus(deps.mediaStatus("microphone")),+ camera: mediaPermissionStatus(deps.mediaStatus("camera")),+ };+ }++ function openSettings(kind: PermissionKind): Promise<void> {+ return deps.openExternal(permissionSettingsUrl(kind));+ }++ /**+ * Does whatever can move `kind` towards granted: raises macOS' prompt the first time,+ * and opens the matching System Settings pane once a prompt can no longer appear.+ */+ async function request(kind: PermissionKind): Promise<void> {+ if (deps.platform !== "darwin") {+ return;+ }+ const status = (await read())[kind];++ if (status === "granted" || status === "restricted") {+ return;+ }+ if (status === "denied") {+ await openSettings(kind);+ return;+ }++ switch (kind) {+ case "screen":+ // Noted before raising: if the app quits with the prompt still up, the next+ // launch must offer System Settings, not a prompt macOS will not show again.+ deps.store.markRequested("screen");+ deps.raiseScreenPrompt();+ return;+ case "accessibility":+ deps.store.markRequested("accessibility");+ deps.accessibilityTrusted(true);+ return;+ case "microphone":+ case "camera":+ await deps.askForMedia(kind);+ return;+ }+ }++ /** For a prompt raised elsewhere -- the cursor helper raises Accessibility's itself. */+ function noteRequested(kind: NotedKind): void {+ deps.store.markRequested(kind);+ }++ return { read, request, openSettings, noteRequested };+}++export type MacPermissions = ReturnType<typeof createMacPermissions>;diff --git a/electron/preload.ts b/electron/preload.tsindex 93494593e..ebefc7a1d 100644--- a/electron/preload.ts+++ b/electron/preload.ts@@ -157,8 +157,12 @@ contextBridge.exposeInMainWorld("electronAPI", {requestCameraAccess: () => {return ipcRenderer.invoke("request-camera-access");},- requestScreenAccess: () => {- return ipcRenderer.invoke("request-screen-access");+ permissions: {+ get: () => ipcRenderer.invoke("permissions:get"),+ request: (kind: string) => ipcRenderer.invoke("permissions:request", kind),+ openSettings: (kind: string) => ipcRenderer.invoke("permissions:open-settings", kind),+ relaunch: () => ipcRenderer.invoke("permissions:relaunch"),+ close: () => ipcRenderer.invoke("permissions:close"),},requestNativeMacCursorAccess: () => {return ipcRenderer.invoke("request-native-mac-cursor-access");diff --git a/electron/windows.ts b/electron/windows.tsindex 634392755..b8e0c2adf 100644--- a/electron/windows.ts+++ b/electron/windows.ts@@ -654,6 +654,47 @@ export function createCountdownOverlayWindow(): BrowserWindow {return win;}+/**+ * The macOS permissions window: first run, the app menu, and wherever a missing permission+ * would otherwise stop a recording. An ordinary opaque window on purpose -- it has to sit+ * beside System Settings and macOS' own prompts, not float above them like the HUD.+ */+export function createPermissionsWindow(): BrowserWindow {+ const win = new BrowserWindow({+ width: 520,+ height: 640,+ resizable: false,+ minimizable: false,+ maximizable: false,+ fullscreenable: false,+ title: "OpenScreen",+ backgroundColor: "#0b0c0f",+ show: false,+ webPreferences: {+ preload: path.join(__dirname, "preload.mjs"),+ additionalArguments: [ASSET_BASE_URL_ARG],+ nodeIntegration: false,+ contextIsolation: true,+ },+ });++ win.once("ready-to-show", () => {+ if (!HEADLESS) {+ win.show();+ }+ });++ if (VITE_DEV_SERVER_URL) {+ win.loadURL(VITE_DEV_SERVER_URL + "?windowType=permissions");+ } else {+ win.loadFile(path.join(RENDERER_DIST, "index.html"), {+ query: { windowType: "permissions" },+ });+ }++ return win;+}+// Frameless Notes Window for taking notes during a recording.export function createNotesWindow(): BrowserWindow {const win = new BrowserWindow({diff --git a/src/App.tsx b/src/App.tsxindex aa7619d26..2d4dd051c 100644--- a/src/App.tsx+++ b/src/App.tsx@@ -9,6 +9,7 @@ import { CountdownOverlay } from "./components/launch/CountdownOverlay.tsx";import { LaunchWindow } from "./components/launch/LaunchWindow";import { NotesWindow } from "./components/launch/NotesWindow.tsx";import { SourceSelector } from "./components/launch/SourceSelector";+import { PermissionsWindow } from "./components/permissions/PermissionsWindow";import { Toaster } from "./components/ui/sonner";import { TooltipProvider } from "./components/ui/tooltip";import { EditorDialogsProvider } from "./contexts/EditorDialogsContext";@@ -86,6 +87,8 @@ export default function App() {return <SourceSelector />;case "countdown-overlay":return <CountdownOverlay />;+ case "permissions":+ return <PermissionsWindow />;case "cli-export":return (<Suspense fallback={null}>diff --git a/src/components/launch/LaunchWindow.test.tsx b/src/components/launch/LaunchWindow.test.tsxindex ebf319e65..6e011c558 100644--- a/src/components/launch/LaunchWindow.test.tsx+++ b/src/components/launch/LaunchWindow.test.tsx@@ -220,11 +220,6 @@ function stubElectronAPI(getSelectedSource: Window["electronAPI"]["getSelectedSo...window.electronAPI,getSelectedSource,openSourceSelector: vi.fn(async () => ({ opened: true })),- requestScreenAccess: vi.fn(async () => ({- success: true,- granted: true,- status: "granted",- })),// Follows the platform under test. Pinned to "darwin" before, which was// invisible while only `nativeBridgeClient` was consulted for it — and// silently wrong the moment anything read the platform through here.diff --git a/src/components/launch/LaunchWindow.tsx b/src/components/launch/LaunchWindow.tsxindex 60fe9be18..33ea3ef39 100644--- a/src/components/launch/LaunchWindow.tsx+++ b/src/components/launch/LaunchWindow.tsx@@ -44,7 +44,6 @@ import {HUD_STACK_GAP,} from "./hudGeometry";import styles from "./LaunchWindow.module.css";-import { openSourceSelectorWithPermissionRetry } from "./openSourceSelectorFlow";// Locale list is computed once at module load; keeping the reference stable lets// the language menu sit behind a memo boundary.@@ -717,11 +716,10 @@ export function LaunchWindow() {}, [applySelectedSource, recording, startWhenDevicesReady]);const openSourceSelector = useCallback(async () => {+ // A missing macOS permission is handled on the main side: it opens the permissions+ // window and answers `screen-access-required`, so there is nothing to retry here.if (window.electronAPI) {- return await openSourceSelectorWithPermissionRetry({- openSourceSelector: () => window.electronAPI.openSourceSelector(),- requestScreenAccess: () => window.electronAPI.requestScreenAccess(),- });+ return await window.electronAPI.openSourceSelector();}return { opened: false, reason: "electron-api-unavailable" };diff --git a/src/components/launch/openSourceSelectorFlow.test.ts b/src/components/launch/openSourceSelectorFlow.test.tsdeleted file mode 100644index ac80f1adc..000000000--- a/src/components/launch/openSourceSelectorFlow.test.ts+++ /dev/null@@ -1,73 +0,0 @@-import { describe, expect, it, vi } from "vitest";-import { openSourceSelectorWithPermissionRetry } from "./openSourceSelectorFlow";--describe("openSourceSelectorWithPermissionRetry", () => {- it("returns immediately when the source selector opens on the first attempt", async () => {- const openSourceSelector = vi.fn().mockResolvedValue({ opened: true });- const requestScreenAccess = vi.fn();-- const result = await openSourceSelectorWithPermissionRetry({- openSourceSelector,- requestScreenAccess,- wait: vi.fn(),- });-- expect(result).toEqual({ opened: true });- expect(openSourceSelector).toHaveBeenCalledTimes(1);- expect(requestScreenAccess).not.toHaveBeenCalled();- });-- it("retries opening after macOS screen permission becomes granted", async () => {- const openSourceSelector = vi- .fn()- .mockResolvedValueOnce({- opened: false,- reason: "screen-access-required",- access: { success: true, granted: false, status: "not-determined" },- })- .mockResolvedValueOnce({ opened: true });- const requestScreenAccess = vi- .fn()- .mockResolvedValueOnce({ success: true, granted: false, status: "not-determined" })- .mockResolvedValueOnce({ success: true, granted: true, status: "granted" });- const wait = vi.fn().mockResolvedValue(undefined);-- const result = await openSourceSelectorWithPermissionRetry({- openSourceSelector,- requestScreenAccess,- wait,- maxAttempts: 4,- });-- expect(result).toEqual({ opened: true });- expect(wait).toHaveBeenCalledTimes(2);- expect(requestScreenAccess).toHaveBeenCalledTimes(2);- expect(openSourceSelector).toHaveBeenCalledTimes(2);- });-- it("stops retrying once macOS permission is explicitly denied", async () => {- const openSourceSelector = vi.fn().mockResolvedValue({- opened: false,- reason: "screen-access-required",- access: { success: true, granted: false, status: "not-determined" },- });- const requestScreenAccess = vi- .fn()- .mockResolvedValueOnce({ success: true, granted: false, status: "denied" });-- const result = await openSourceSelectorWithPermissionRetry({- openSourceSelector,- requestScreenAccess,- wait: vi.fn(),- maxAttempts: 4,- });-- expect(result).toEqual({- opened: false,- reason: "screen-access-required",- access: { success: true, granted: false, status: "denied" },- });- expect(requestScreenAccess).toHaveBeenCalledTimes(1);- expect(openSourceSelector).toHaveBeenCalledTimes(1);- });-});diff --git a/src/components/launch/openSourceSelectorFlow.ts b/src/components/launch/openSourceSelectorFlow.tsdeleted file mode 100644index 540f1fcef..000000000--- a/src/components/launch/openSourceSelectorFlow.ts+++ /dev/null@@ -1,62 +0,0 @@-export type ScreenAccessResult = {- success: boolean;- granted: boolean;- status: string;- error?: string;-};--export type OpenSourceSelectorResult = {- opened: boolean;- reason?: string;- access?: ScreenAccessResult;-};--type OpenSourceSelectorFlowOptions = {- openSourceSelector: () => Promise<OpenSourceSelectorResult>;- requestScreenAccess: () => Promise<ScreenAccessResult>;- wait?: (ms: number) => Promise<void>;- retryDelayMs?: number;- maxAttempts?: number;-};--const defaultWait = (ms: number) => new Promise<void>((resolve) => window.setTimeout(resolve, ms));--function shouldRetryAfterPermissionPrompt(result: OpenSourceSelectorResult): boolean {- return (- result.opened === false &&- result.reason === "screen-access-required" &&- result.access?.status === "not-determined"- );-}--export async function openSourceSelectorWithPermissionRetry({- openSourceSelector,- requestScreenAccess,- wait = defaultWait,- retryDelayMs = 750,- maxAttempts = 8,-}: OpenSourceSelectorFlowOptions): Promise<OpenSourceSelectorResult> {- const initialResult = await openSourceSelector();- if (!shouldRetryAfterPermissionPrompt(initialResult)) {- return initialResult;- }-- for (let attempt = 0; attempt < maxAttempts; attempt += 1) {- await wait(retryDelayMs);- const access = await requestScreenAccess();-- if (access.granted) {- return openSourceSelector();- }-- if (access.status !== "not-determined") {- return {- opened: false,- reason: "screen-access-required",- access,- };- }- }-- return initialResult;-}diff --git a/src/components/permissions/PermissionsWindow.test.tsx b/src/components/permissions/PermissionsWindow.test.tsxnew file mode 100644index 000000000..3b64f57f6--- /dev/null+++ b/src/components/permissions/PermissionsWindow.test.tsx@@ -0,0 +1,137 @@+// @vitest-environment jsdom+import "@testing-library/jest-dom";+import { act, fireEvent, render, screen, waitFor, within } from "@testing-library/react";+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import { PERMISSIONS_POLL_MS, PermissionsWindow } from "./PermissionsWindow";++vi.mock("@/contexts/I18nContext", () => ({+ // Keys come back verbatim, so the assertions read as the contract, not as copy.+ useScopedT: () => (key: string) => key,+}));++type PermissionsApi = Window["electronAPI"]["permissions"];+type Snapshot = Awaited<ReturnType<PermissionsApi["get"]>>;++const FIRST_RUN: Snapshot = {+ supported: true,+ macosMajor: 26,+ screen: "not-requested",+ screenRequiresRelaunch: false,+ accessibility: "not-requested",+ microphone: "not-requested",+ camera: "not-requested",+};++let current: Snapshot;+let api: { [K in keyof PermissionsApi]: ReturnType<typeof vi.fn> };++beforeEach(() => {+ current = { ...FIRST_RUN };+ api = {+ get: vi.fn(async () => current),+ request: vi.fn(async () => undefined),+ openSettings: vi.fn(async () => undefined),+ relaunch: vi.fn(async () => undefined),+ close: vi.fn(async () => undefined),+ };+ window.electronAPI = {+ ...window.electronAPI,+ permissions: api as unknown as PermissionsApi,+ };+});++afterEach(() => {+ vi.useRealTimers();+});++async function renderWith(snapshot: Partial<Snapshot>) {+ current = { ...FIRST_RUN, ...snapshot };+ render(<PermissionsWindow />);+ await screen.findByTestId("permission-screen");+}++describe("PermissionsWindow", () => {+ it("offers Continue, not Allow, for Screen Recording on a first run", async () => {+ await renderWith({});++ const button = screen.getByTestId("permission-screen-action");+ expect(button).toHaveTextContent("permissions.actions.continue");+ expect(screen.getByTestId("permission-microphone-action")).toHaveTextContent(+ "permissions.actions.allow",+ );+ expect(screen.getByText("permissions.help.screenPrompt")).toBeInTheDocument();++ fireEvent.click(button);+ await waitFor(() => expect(api.request).toHaveBeenCalledWith("screen"));+ expect(api.openSettings).not.toHaveBeenCalled();+ });++ it("sends a refused permission to System Settings, with help for a missing entry", async () => {+ await renderWith({ screen: "denied" });++ const button = screen.getByTestId("permission-screen-action");+ expect(button).toHaveTextContent("permissions.actions.openSettings");+ expect(screen.getByText("permissions.help.screenNotListed")).toBeInTheDocument();++ fireEvent.click(button);+ await waitFor(() => expect(api.openSettings).toHaveBeenCalledWith("screen"));+ expect(api.request).not.toHaveBeenCalled();+ });++ it("keeps Get started disabled until Screen Recording is granted", async () => {+ await renderWith({ accessibility: "granted", microphone: "granted", camera: "granted" });++ expect(screen.getByTestId("permissions-start")).toBeDisabled();+ expect(screen.getByText("permissions.footer.screenRequired")).toBeInTheDocument();+ });++ it("lets the user start once Screen Recording is granted, whatever the optional ones say", async () => {+ await renderWith({ screen: "granted", camera: "denied" });++ const start = screen.getByTestId("permissions-start");+ expect(start).toBeEnabled();+ fireEvent.click(start);+ expect(api.close).toHaveBeenCalled();+ });++ it("offers the relaunch when the grant is not usable by this process yet", async () => {+ await renderWith({ screen: "granted", screenRequiresRelaunch: true });++ expect(screen.queryByTestId("permissions-start")).not.toBeInTheDocument();+ expect(screen.getByText("permissions.help.screenRestart")).toBeInTheDocument();+ fireEvent.click(screen.getByTestId("permissions-relaunch"));+ expect(api.relaunch).toHaveBeenCalled();+ });++ it("warns about macOS' recurring confirmation only from macOS 15", async () => {+ await renderWith({ screen: "granted", macosMajor: 15 });+ expect(screen.getByText("permissions.help.screenRecurring")).toBeInTheDocument();+ });++ it("says nothing about it on macOS 14", async () => {+ await renderWith({ screen: "granted", macosMajor: 14 });+ expect(screen.queryByText("permissions.help.screenRecurring")).not.toBeInTheDocument();+ });++ it("shows a policy-restricted permission without a button", async () => {+ await renderWith({ microphone: "restricted" });++ const row = screen.getByTestId("permission-microphone");+ expect(within(row).getByText("permissions.status.restricted")).toBeInTheDocument();+ expect(screen.queryByTestId("permission-microphone-action")).not.toBeInTheDocument();+ });++ it("follows a grant made in System Settings without any click", async () => {+ vi.useFakeTimers({ shouldAdvanceTime: true });+ await renderWith({ screen: "denied" });+ expect(screen.getByTestId("permission-screen")).toHaveAttribute("data-status", "denied");++ current = { ...current, screen: "granted" };+ await act(async () => {+ await vi.advanceTimersByTimeAsync(PERMISSIONS_POLL_MS);+ });++ expect(screen.getByTestId("permission-screen")).toHaveAttribute("data-status", "granted");+ expect(screen.getByTestId("permissions-start")).toBeEnabled();+ });+});diff --git a/src/components/permissions/PermissionsWindow.tsx b/src/components/permissions/PermissionsWindow.tsxnew file mode 100644index 000000000..c70af98c3--- /dev/null+++ b/src/components/permissions/PermissionsWindow.tsx@@ -0,0 +1,251 @@+import { Accessibility, Check, Mic, MonitorPlay, Video } from "lucide-react";+import { useCallback, useEffect, useRef, useState } from "react";+import { useScopedT } from "@/contexts/I18nContext";++type PermissionsApi = Window["electronAPI"]["permissions"];+type Snapshot = Awaited<ReturnType<PermissionsApi["get"]>>;+type Kind = Parameters<PermissionsApi["request"]>[0];+type Status = Snapshot["screen"];++/**+ * How often the statuses are re-read while the window is open. The user changes them in+ * System Settings, which tells no one, so polling is the only way to follow along; each+ * Screen Recording read spawns a short-lived helper, which is cheap at this rate.+ */+export const PERMISSIONS_POLL_MS = 500;++const ROWS: ReadonlyArray<{+ kind: Kind;+ level: "required" | "recommended" | "optional";+ Icon: typeof MonitorPlay;+}> = [+ { kind: "screen", level: "required", Icon: MonitorPlay },+ { kind: "accessibility", level: "recommended", Icon: Accessibility },+ { kind: "microphone", level: "optional", Icon: Mic },+ { kind: "camera", level: "optional", Icon: Video },+];++/** macOS 15 re-confirms ScreenCaptureKit access periodically for every app that uses it. */+const RECURRING_SCREEN_ALERT_FROM_MACOS = 15;++export function PermissionsWindow() {+ const t = useScopedT("launch");+ const [snapshot, setSnapshot] = useState<Snapshot | null>(null);+ const [busy, setBusy] = useState<Kind | null>(null);+ const mounted = useRef(true);++ const refresh = useCallback(async () => {+ try {+ const next = await window.electronAPI.permissions.get();+ if (mounted.current) {+ setSnapshot(next);+ }+ } catch (error) {+ console.warn("[permissions] read failed:", error);+ }+ }, []);++ useEffect(() => {+ mounted.current = true;+ let timer: number | undefined;+ // Sequential rather than setInterval: a slow read must not stack up behind itself.+ const tick = async () => {+ await refresh();+ if (mounted.current) {+ timer = window.setTimeout(tick, PERMISSIONS_POLL_MS);+ }+ };+ void tick();+ return () => {+ mounted.current = false;+ window.clearTimeout(timer);+ };+ }, [refresh]);++ const act = useCallback(+ async (kind: Kind, status: Status) => {+ setBusy(kind);+ try {+ if (status === "denied") {+ await window.electronAPI.permissions.openSettings(kind);+ } else {+ await window.electronAPI.permissions.request(kind);+ }+ await refresh();+ } finally {+ if (mounted.current) {+ setBusy(null);+ }+ }+ },+ [refresh],+ );++ if (!snapshot) {+ return <div className="h-screen bg-[#0b0c0f]" />;+ }++ const screenReady = snapshot.screen === "granted" && !snapshot.screenRequiresRelaunch;+ const needsRelaunch = snapshot.screen === "granted" && snapshot.screenRequiresRelaunch;++ return (+ <div className="flex h-screen flex-col bg-[#0b0c0f] px-7 pt-7 pb-6 text-white select-none">+ <h1 className="text-[17px] font-semibold">{t("permissions.title")}</h1>+ <p className="mt-1.5 text-[12px] leading-5 text-[#8b93a1]">{t("permissions.subtitle")}</p>++ <ul className="mt-5 flex flex-col gap-2.5">+ {ROWS.map(({ kind, level, Icon }) => {+ const status = snapshot[kind];+ return (+ <li+ key={kind}+ data-testid={`permission-${kind}`}+ data-status={status}+ className="rounded-xl border border-[#20232a] bg-[#121419] px-4 py-3"+ >+ <div className="flex items-center gap-3">+ <Icon className="h-5 w-5 shrink-0 text-[#10b981]" aria-hidden />+ <div className="min-w-0 flex-1">+ <div className="flex items-center gap-2">+ <span className="text-[13px] font-medium">+ {t(`permissions.rows.${kind}.name`)}+ </span>+ <span className="rounded-full bg-[#1c1f26] px-2 py-px text-[10px] text-[#8b93a1]">+ {t(`permissions.level.${level}`)}+ </span>+ </div>+ <p className="mt-0.5 text-[11px] leading-4 text-[#8b93a1]">+ {t(`permissions.rows.${kind}.description`)}+ </p>+ </div>+ <PermissionAction+ kind={kind}+ status={status}+ busy={busy === kind}+ onAct={() => void act(kind, status)}+ t={t}+ />+ </div>+ {kind === "screen" && (+ <ScreenHelp snapshot={snapshot} needsRelaunch={needsRelaunch} t={t} />+ )}+ </li>+ );+ })}+ </ul>++ <div className="mt-auto flex items-center justify-between gap-4 pt-5">+ <p className="text-[11px] leading-4 text-[#8b93a1]">+ {screenReady ? t("permissions.footer.ready") : t("permissions.footer.screenRequired")}+ </p>+ {needsRelaunch ? (+ <button+ type="button"+ data-testid="permissions-relaunch"+ onClick={() => void window.electronAPI.permissions.relaunch()}+ className="h-9 shrink-0 rounded-[9px] bg-[#10b981] px-5 text-[12px] font-semibold text-[#08090d] hover:bg-[#10b981]/85"+ >+ {t("permissions.actions.restart")}+ </button>+ ) : (+ <button+ type="button"+ data-testid="permissions-start"+ disabled={!screenReady}+ onClick={() => void window.electronAPI.permissions.close()}+ className="h-9 shrink-0 rounded-[9px] bg-[#10b981] px-5 text-[12px] font-semibold text-[#08090d] hover:bg-[#10b981]/85 disabled:cursor-not-allowed disabled:opacity-40"+ >+ {t("permissions.actions.start")}+ </button>+ )}+ </div>+ </div>+ );+}++type T = ReturnType<typeof useScopedT>;++function PermissionAction({+ kind,+ status,+ busy,+ onAct,+ t,+}: {+ kind: Kind;+ status: Status;+ busy: boolean;+ onAct: () => void;+ t: T;+}) {+ if (status === "granted") {+ return (+ <span className="flex shrink-0 items-center gap-1 text-[12px] font-medium text-[#10b981]">+ <Check className="h-4 w-4" aria-hidden />+ {t("permissions.status.granted")}+ </span>+ );+ }+ if (status === "restricted") {+ return (+ <span className="max-w-[120px] shrink-0 text-right text-[11px] leading-4 text-[#8b93a1]">+ {t("permissions.status.restricted")}+ </span>+ );+ }++ // Screen Recording's first step says "Continue", not "Allow": macOS' own prompt has no+ // Allow button, only a way into System Settings, and the label must not promise one.+ const label =+ status === "denied"+ ? t("permissions.actions.openSettings")+ : kind === "screen"+ ? t("permissions.actions.continue")+ : t("permissions.actions.allow");++ return (+ <button+ type="button"+ data-testid={`permission-${kind}-action`}+ disabled={busy}+ onClick={onAct}+ className="h-8 shrink-0 rounded-[8px] bg-[#1f232b] px-3.5 text-[12px] font-medium text-white hover:bg-[#2a2f39] disabled:opacity-50"+ >+ {label}+ </button>+ );+}++function ScreenHelp({+ snapshot,+ needsRelaunch,+ t,+}: {+ snapshot: Snapshot;+ needsRelaunch: boolean;+ t: T;+}) {+ const lines: string[] = [];+ if (needsRelaunch) {+ lines.push(t("permissions.help.screenRestart"));+ } else if (snapshot.screen === "denied") {+ lines.push(t("permissions.help.screenSettings"), t("permissions.help.screenNotListed"));+ } else if (snapshot.screen === "not-requested") {+ lines.push(t("permissions.help.screenPrompt"));+ }+ if (snapshot.screen === "granted" && snapshot.macosMajor >= RECURRING_SCREEN_ALERT_FROM_MACOS) {+ lines.push(t("permissions.help.screenRecurring"));+ }+ if (lines.length === 0) {+ return null;+ }+ return (+ <div className="mt-2.5 space-y-1 border-t border-[#20232a] pt-2.5 pl-8">+ {lines.map((line) => (+ <p key={line} className="text-[11px] leading-4 text-[#a9b0bc]">+ {line}+ </p>+ ))}+ </div>+ );+}diff --git a/src/i18n/locales/ar/common.json b/src/i18n/locales/ar/common.jsonindex 530deaf55..62c1b7b6c 100644--- a/src/i18n/locales/ar/common.json+++ b/src/i18n/locales/ar/common.json@@ -45,7 +45,8 @@"hide": "إخفاء OpenScreen","hideOthers": "إخفاء الآخرين","unhide": "إظهار الكل",- "saveDiagnostics": "حفظ التشخيصات"+ "saveDiagnostics": "حفظ التشخيصات",+ "permissions": "الأذونات…"},"updates": {"available": "يتوفر OpenScreen {{latestVersion}}. الإصدار المثبت هو {{currentVersion}}.",diff --git a/src/i18n/locales/ar/launch.json b/src/i18n/locales/ar/launch.jsonindex 0198af382..a19bd22a9 100644--- a/src/i18n/locales/ar/launch.json+++ b/src/i18n/locales/ar/launch.json@@ -95,5 +95,54 @@"about": "حول","version": "الإصدار {{version}}","checkingForUpdates": "جارٍ التحقق…"+ },+ "permissions": {+ "title": "يحتاج OpenScreen إلى بعض الأذونات",+ "subtitle": "يطلب منك macOS منح كل إذن مرة واحدة فقط. يمكنك تغييرها في أي وقت من إعدادات النظام.",+ "level": {+ "required": "مطلوب",+ "recommended": "مُوصى به",+ "optional": "اختياري"+ },+ "rows": {+ "screen": {+ "name": "الشاشة وصوت النظام",+ "description": "لتسجيل شاشتك والصوت الصادر من جهاز Mac."+ },+ "accessibility": {+ "name": "تسهيلات الاستخدام",+ "description": "لإظهار المؤشر الصحيح (سهم، نص) في تسجيلاتك."+ },+ "microphone": {+ "name": "الميكروفون",+ "description": "لتسجيل صوتك."+ },+ "camera": {+ "name": "الكاميرا",+ "description": "لإضافة كاميرا الويب إلى تسجيلاتك."+ }+ },+ "status": {+ "granted": "مسموح",+ "restricted": "تتم إدارته من قِبل مؤسستك"+ },+ "actions": {+ "continue": "متابعة",+ "allow": "سماح",+ "openSettings": "فتح الإعدادات",+ "restart": "إعادة تشغيل OpenScreen",+ "start": "ابدأ"+ },+ "help": {+ "screenPrompt": "سيطلب منك macOS بعد ذلك تفعيل OpenScreen في إعدادات النظام.",+ "screenSettings": "في إعدادات النظام، فعِّل OpenScreen. إذا عرض macOS إنهاء التطبيق وإعادة فتحه، فوافق: ستعود هذه النافذة.",+ "screenNotListed": "لا يظهر OpenScreen في القائمة؟ انقر على +، ثم اختر OpenScreen من التطبيقات.",+ "screenRestart": "مسموح. يجب إعادة تشغيل OpenScreen ليتمكن من استخدامه.",+ "screenRecurring": "سيطلب منك macOS من حين لآخر تأكيد هذا الوصول. هذا أمر طبيعي."+ },+ "footer": {+ "screenRequired": "تسجيل الشاشة مطلوب للتسجيل.",+ "ready": "كل شيء جاهز."+ }}}diff --git a/src/i18n/locales/cs/common.json b/src/i18n/locales/cs/common.jsonindex c68a3e456..a3deb4c3b 100644--- a/src/i18n/locales/cs/common.json+++ b/src/i18n/locales/cs/common.json@@ -45,7 +45,8 @@"hide": "Skrýt OpenScreen","hideOthers": "Skrýt ostatní","unhide": "Zobrazit vše",- "saveDiagnostics": "Uložit diagnostiku"+ "saveDiagnostics": "Uložit diagnostiku",+ "permissions": "Oprávnění…"},"updates": {"available": "OpenScreen {{latestVersion}} je k dispozici. Používáte verzi {{currentVersion}}.",diff --git a/src/i18n/locales/cs/launch.json b/src/i18n/locales/cs/launch.jsonindex 87dbef6c3..6a44f4a6a 100644--- a/src/i18n/locales/cs/launch.json+++ b/src/i18n/locales/cs/launch.json@@ -95,5 +95,54 @@"about": "O aplikaci","version": "Verze {{version}}","checkingForUpdates": "Kontrola…"+ },+ "permissions": {+ "title": "OpenScreen potřebuje několik oprávnění",+ "subtitle": "macOS vás o každé požádá jen jednou. Kdykoli je můžete změnit v Nastavení systému.",+ "level": {+ "required": "Povinné",+ "recommended": "Doporučené",+ "optional": "Volitelné"+ },+ "rows": {+ "screen": {+ "name": "Obrazovka a zvuk systému",+ "description": "K nahrávání obrazovky a zvuku z vašeho Macu."+ },+ "accessibility": {+ "name": "Zpřístupnění",+ "description": "Aby nahrávky zobrazovaly správný kurzor (šipka, text)."+ },+ "microphone": {+ "name": "Mikrofon",+ "description": "K nahrávání vašeho hlasu."+ },+ "camera": {+ "name": "Kamera",+ "description": "K přidání webkamery do nahrávek."+ }+ },+ "status": {+ "granted": "Povoleno",+ "restricted": "Spravováno vaší organizací"+ },+ "actions": {+ "continue": "Pokračovat",+ "allow": "Povolit",+ "openSettings": "Otevřít Nastavení",+ "restart": "Restartovat OpenScreen",+ "start": "Začít"+ },+ "help": {+ "screenPrompt": "macOS vás pak požádá, abyste OpenScreen zapnuli v Nastavení systému.",+ "screenSettings": "V Nastavení systému zapněte OpenScreen. Pokud macOS nabídne aplikaci ukončit a znovu otevřít, přijměte: toto okno se vrátí.",+ "screenNotListed": "OpenScreen v seznamu chybí? Klikněte na + a vyberte OpenScreen ve složce Aplikace.",+ "screenRestart": "Povoleno. OpenScreen se musí restartovat, aby oprávnění mohl použít.",+ "screenRecurring": "macOS vás občas požádá o potvrzení tohoto přístupu. To je v pořádku."+ },+ "footer": {+ "screenRequired": "K nahrávání je potřeba nahrávání obrazovky.",+ "ready": "Vše je připraveno."+ }}}diff --git a/src/i18n/locales/de/common.json b/src/i18n/locales/de/common.jsonindex 194818720..c1e4b5462 100644--- a/src/i18n/locales/de/common.json+++ b/src/i18n/locales/de/common.json@@ -45,7 +45,8 @@"hide": "OpenScreen ausblenden","hideOthers": "Andere ausblenden","unhide": "Alle einblenden",- "saveDiagnostics": "Diagnosedaten speichern"+ "saveDiagnostics": "Diagnosedaten speichern",+ "permissions": "Berechtigungen …"},"updates": {"available": "OpenScreen {{latestVersion}} ist verfügbar. Du verwendest {{currentVersion}}.",diff --git a/src/i18n/locales/de/launch.json b/src/i18n/locales/de/launch.jsonindex 0f2e8cc65..9aa284046 100644--- a/src/i18n/locales/de/launch.json+++ b/src/i18n/locales/de/launch.json@@ -95,5 +95,54 @@"about": "Über","version": "Version {{version}}","checkingForUpdates": "Wird geprüft…"+ },+ "permissions": {+ "title": "OpenScreen benötigt einige Berechtigungen",+ "subtitle": "macOS fragt jede Berechtigung nur einmal ab. Du kannst sie jederzeit in den Systemeinstellungen ändern.",+ "level": {+ "required": "Erforderlich",+ "recommended": "Empfohlen",+ "optional": "Optional"+ },+ "rows": {+ "screen": {+ "name": "Bildschirm & Systemaudio",+ "description": "Um deinen Bildschirm und den Ton deines Mac aufzunehmen."+ },+ "accessibility": {+ "name": "Bedienungshilfen",+ "description": "Um in Aufnahmen den richtigen Zeiger (Pfeil, Text) anzuzeigen."+ },+ "microphone": {+ "name": "Mikrofon",+ "description": "Um deine Stimme aufzunehmen."+ },+ "camera": {+ "name": "Kamera",+ "description": "Um deine Webcam zu Aufnahmen hinzuzufügen."+ }+ },+ "status": {+ "granted": "Erlaubt",+ "restricted": "Von deiner Organisation verwaltet"+ },+ "actions": {+ "continue": "Weiter",+ "allow": "Erlauben",+ "openSettings": "Einstellungen öffnen",+ "restart": "OpenScreen neu starten",+ "start": "Los geht's"+ },+ "help": {+ "screenPrompt": "macOS bittet dich anschließend, OpenScreen in den Systemeinstellungen zu aktivieren.",+ "screenSettings": "Aktiviere OpenScreen in den Systemeinstellungen. Wenn macOS anbietet, die App zu beenden und neu zu öffnen, stimme zu: Dieses Fenster erscheint wieder.",+ "screenNotListed": "OpenScreen fehlt in der Liste? Klicke auf + und wähle OpenScreen unter „Programme“.",+ "screenRestart": "Erlaubt. OpenScreen muss neu starten, um die Berechtigung zu nutzen.",+ "screenRecurring": "macOS bittet dich gelegentlich, diesen Zugriff zu bestätigen. Das ist normal."+ },+ "footer": {+ "screenRequired": "Zum Aufnehmen ist die Bildschirmaufnahme erforderlich.",+ "ready": "Alles bereit."+ }}}diff --git a/src/i18n/locales/en/common.json b/src/i18n/locales/en/common.jsonindex d1dd7d085..ab9a46b00 100644--- a/src/i18n/locales/en/common.json+++ b/src/i18n/locales/en/common.json@@ -45,7 +45,8 @@"hide": "Hide OpenScreen","hideOthers": "Hide Others","unhide": "Show All",- "saveDiagnostics": "Save Diagnostics"+ "saveDiagnostics": "Save Diagnostics",+ "permissions": "Permissions…"},"updates": {"available": "OpenScreen {{latestVersion}} is available. You are using {{currentVersion}}.",diff --git a/src/i18n/locales/en/launch.json b/src/i18n/locales/en/launch.jsonindex ad2385c02..263b4e9b9 100644--- a/src/i18n/locales/en/launch.json+++ b/src/i18n/locales/en/launch.json@@ -95,5 +95,54 @@"about": "About","version": "Version {{version}}","checkingForUpdates": "Checking…"+ },+ "permissions": {+ "title": "OpenScreen needs a few permissions",+ "subtitle": "macOS asks you to grant each one once. You can change them at any time in System Settings.",+ "level": {+ "required": "Required",+ "recommended": "Recommended",+ "optional": "Optional"+ },+ "rows": {+ "screen": {+ "name": "Screen & system audio",+ "description": "To record your screen and the sound your Mac plays."+ },+ "accessibility": {+ "name": "Accessibility",+ "description": "To show the right cursor (pointer, text) in your recordings."+ },+ "microphone": {+ "name": "Microphone",+ "description": "To record your voice."+ },+ "camera": {+ "name": "Camera",+ "description": "To add your webcam to your recordings."+ }+ },+ "status": {+ "granted": "Allowed",+ "restricted": "Managed by your organization"+ },+ "actions": {+ "continue": "Continue",+ "allow": "Allow",+ "openSettings": "Open Settings",+ "restart": "Restart OpenScreen",+ "start": "Get started"+ },+ "help": {+ "screenPrompt": "macOS will then ask you to turn on OpenScreen in System Settings.",+ "screenSettings": "In System Settings, turn on OpenScreen. If macOS offers to quit and reopen it, accept: this window will come back.",+ "screenNotListed": "OpenScreen isn't in the list? Click +, then choose OpenScreen in Applications.",+ "screenRestart": "Allowed. OpenScreen needs to restart before it can use it.",+ "screenRecurring": "macOS will occasionally ask you to confirm this access. That's expected."+ },+ "footer": {+ "screenRequired": "Screen recording is needed to record.",+ "ready": "You're all set."+ }}}diff --git a/src/i18n/locales/es/common.json b/src/i18n/locales/es/common.jsonindex 92de74416..d067e7562 100644--- a/src/i18n/locales/es/common.json+++ b/src/i18n/locales/es/common.json@@ -45,7 +45,8 @@"hide": "Ocultar OpenScreen","hideOthers": "Ocultar otros","unhide": "Mostrar todo",- "saveDiagnostics": "Guardar diagnósticos"+ "saveDiagnostics": "Guardar diagnósticos",+ "permissions": "Permisos…"},"updates": {"available": "OpenScreen {{latestVersion}} está disponible. Estás usando {{currentVersion}}.",diff --git a/src/i18n/locales/es/launch.json b/src/i18n/locales/es/launch.jsonindex 7a2c92a55..4587d841d 100644--- a/src/i18n/locales/es/launch.json+++ b/src/i18n/locales/es/launch.json@@ -95,5 +95,54 @@"about": "Acerca de","version": "Versión {{version}}","checkingForUpdates": "Buscando…"+ },+ "permissions": {+ "title": "OpenScreen necesita algunos permisos",+ "subtitle": "macOS te pide concederlos una sola vez. Puedes cambiarlos en cualquier momento en Ajustes del Sistema.",+ "level": {+ "required": "Obligatorio",+ "recommended": "Recomendado",+ "optional": "Opcional"+ },+ "rows": {+ "screen": {+ "name": "Pantalla y audio del sistema",+ "description": "Para grabar tu pantalla y el sonido de tu Mac."+ },+ "accessibility": {+ "name": "Accesibilidad",+ "description": "Para mostrar el cursor correcto (flecha, texto) en tus grabaciones."+ },+ "microphone": {+ "name": "Micrófono",+ "description": "Para grabar tu voz."+ },+ "camera": {+ "name": "Cámara",+ "description": "Para añadir tu webcam a tus grabaciones."+ }+ },+ "status": {+ "granted": "Permitido",+ "restricted": "Gestionado por tu organización"+ },+ "actions": {+ "continue": "Continuar",+ "allow": "Permitir",+ "openSettings": "Abrir Ajustes",+ "restart": "Reiniciar OpenScreen",+ "start": "Empezar"+ },+ "help": {+ "screenPrompt": "Después, macOS te pedirá que actives OpenScreen en Ajustes del Sistema.",+ "screenSettings": "En Ajustes del Sistema, activa OpenScreen. Si macOS ofrece cerrarlo y volver a abrirlo, acepta: esta ventana volverá.",+ "screenNotListed": "¿OpenScreen no aparece en la lista? Haz clic en + y elige OpenScreen en Aplicaciones.",+ "screenRestart": "Permitido. OpenScreen debe reiniciarse para poder usarlo.",+ "screenRecurring": "De vez en cuando, macOS te pedirá que confirmes este acceso. Es normal."+ },+ "footer": {+ "screenRequired": "Se necesita la grabación de pantalla para grabar.",+ "ready": "Todo listo."+ }}}diff --git a/src/i18n/locales/fr/common.json b/src/i18n/locales/fr/common.jsonindex 6d5454603..518611716 100644--- a/src/i18n/locales/fr/common.json+++ b/src/i18n/locales/fr/common.json@@ -45,7 +45,8 @@"hide": "Masquer OpenScreen","hideOthers": "Masquer les autres","unhide": "Tout afficher",- "saveDiagnostics": "Enregistrer les diagnostics"+ "saveDiagnostics": "Enregistrer les diagnostics",+ "permissions": "Autorisations…"},"updates": {"available": "OpenScreen {{latestVersion}} est disponible. Vous utilisez la version {{currentVersion}}.",diff --git a/src/i18n/locales/fr/launch.json b/src/i18n/locales/fr/launch.jsonindex 858fd58f1..1d9f5fbb6 100644--- a/src/i18n/locales/fr/launch.json+++ b/src/i18n/locales/fr/launch.json@@ -95,5 +95,54 @@"about": "À propos","version": "Version {{version}}","checkingForUpdates": "Recherche…"+ },+ "permissions": {+ "title": "OpenScreen a besoin de quelques autorisations",+ "subtitle": "macOS vous demande de les accorder une seule fois. Vous pouvez les modifier à tout moment dans Réglages Système.",+ "level": {+ "required": "Obligatoire",+ "recommended": "Recommandée",+ "optional": "Facultative"+ },+ "rows": {+ "screen": {+ "name": "Écran et son du système",+ "description": "Pour enregistrer votre écran et le son de votre Mac."+ },+ "accessibility": {+ "name": "Accessibilité",+ "description": "Pour afficher le bon curseur (flèche, texte) dans vos enregistrements."+ },+ "microphone": {+ "name": "Micro",+ "description": "Pour enregistrer votre voix."+ },+ "camera": {+ "name": "Caméra",+ "description": "Pour ajouter votre webcam à vos enregistrements."+ }+ },+ "status": {+ "granted": "Autorisé",+ "restricted": "Géré par votre organisation"+ },+ "actions": {+ "continue": "Continuer",+ "allow": "Autoriser",+ "openSettings": "Ouvrir Réglages",+ "restart": "Redémarrer OpenScreen",+ "start": "Commencer"+ },+ "help": {+ "screenPrompt": "macOS vous demandera ensuite d'activer OpenScreen dans Réglages Système.",+ "screenSettings": "Dans Réglages Système, activez OpenScreen. Si macOS propose de le quitter et le rouvrir, acceptez : cette fenêtre reviendra.",+ "screenNotListed": "OpenScreen n'apparaît pas dans la liste ? Cliquez sur +, puis choisissez OpenScreen dans Applications.",+ "screenRestart": "Autorisé. OpenScreen doit redémarrer pour pouvoir l'utiliser.",+ "screenRecurring": "macOS vous demandera de temps en temps de confirmer cet accès. C'est normal."+ },+ "footer": {+ "screenRequired": "L'enregistrement de l'écran est nécessaire pour enregistrer.",+ "ready": "Tout est prêt."+ }}}diff --git a/src/i18n/locales/it/common.json b/src/i18n/locales/it/common.jsonindex d831ec93b..9633a8ac1 100644--- a/src/i18n/locales/it/common.json+++ b/src/i18n/locales/it/common.json@@ -45,7 +45,8 @@"hide": "Nascondi OpenScreen","hideOthers": "Nascondi gli altri","unhide": "Mostra tutto",- "saveDiagnostics": "Salva dati diagnostici"+ "saveDiagnostics": "Salva dati diagnostici",+ "permissions": "Permessi…"},"updates": {"available": "OpenScreen {{latestVersion}} è disponibile. Stai usando la versione {{currentVersion}}.",diff --git a/src/i18n/locales/it/launch.json b/src/i18n/locales/it/launch.jsonindex ed5088d67..2a7cc0a96 100644--- a/src/i18n/locales/it/launch.json+++ b/src/i18n/locales/it/launch.json@@ -95,5 +95,54 @@"about": "Info","version": "Versione {{version}}","checkingForUpdates": "Controllo…"+ },+ "permissions": {+ "title": "OpenScreen ha bisogno di alcuni permessi",+ "subtitle": "macOS ti chiede di concederli una sola volta. Puoi modificarli in qualsiasi momento in Impostazioni di Sistema.",+ "level": {+ "required": "Obbligatorio",+ "recommended": "Consigliato",+ "optional": "Facoltativo"+ },+ "rows": {+ "screen": {+ "name": "Schermo e audio di sistema",+ "description": "Per registrare lo schermo e l'audio del tuo Mac."+ },+ "accessibility": {+ "name": "Accessibilità",+ "description": "Per mostrare il cursore giusto (freccia, testo) nelle registrazioni."+ },+ "microphone": {+ "name": "Microfono",+ "description": "Per registrare la tua voce."+ },+ "camera": {+ "name": "Fotocamera",+ "description": "Per aggiungere la webcam alle registrazioni."+ }+ },+ "status": {+ "granted": "Consentito",+ "restricted": "Gestito dalla tua organizzazione"+ },+ "actions": {+ "continue": "Continua",+ "allow": "Consenti",+ "openSettings": "Apri Impostazioni",+ "restart": "Riavvia OpenScreen",+ "start": "Inizia"+ },+ "help": {+ "screenPrompt": "Poi macOS ti chiederà di attivare OpenScreen in Impostazioni di Sistema.",+ "screenSettings": "In Impostazioni di Sistema, attiva OpenScreen. Se macOS propone di chiuderlo e riaprirlo, accetta: questa finestra tornerà.",+ "screenNotListed": "OpenScreen non è nell'elenco? Fai clic su +, poi scegli OpenScreen in Applicazioni.",+ "screenRestart": "Consentito. OpenScreen deve riavviarsi per poterlo usare.",+ "screenRecurring": "Di tanto in tanto macOS ti chiederà di confermare questo accesso. È normale."+ },+ "footer": {+ "screenRequired": "Per registrare serve la registrazione dello schermo.",+ "ready": "È tutto pronto."+ }}}diff --git a/src/i18n/locales/ja-JP/common.json b/src/i18n/locales/ja-JP/common.jsonindex a1375e0ed..55175fa26 100644--- a/src/i18n/locales/ja-JP/common.json+++ b/src/i18n/locales/ja-JP/common.json@@ -45,7 +45,8 @@"hide": "OpenScreenを隠す","hideOthers": "ほかを隠す","unhide": "すべて表示",- "saveDiagnostics": "診断情報を保存"+ "saveDiagnostics": "診断情報を保存",+ "permissions": "アクセス許可…"},"updates": {"available": "OpenScreen {{latestVersion}} を利用できます。現在のバージョンは {{currentVersion}} です。",diff --git a/src/i18n/locales/ja-JP/launch.json b/src/i18n/locales/ja-JP/launch.jsonindex ab9cebbd5..9dc54e90a 100644--- a/src/i18n/locales/ja-JP/launch.json+++ b/src/i18n/locales/ja-JP/launch.json@@ -95,5 +95,54 @@"about": "情報","version": "バージョン {{version}}","checkingForUpdates": "確認中…"+ },+ "permissions": {+ "title": "OpenScreen にはいくつかの許可が必要です",+ "subtitle": "macOS ではそれぞれ一度だけ許可します。システム設定でいつでも変更できます。",+ "level": {+ "required": "必須",+ "recommended": "推奨",+ "optional": "任意"+ },+ "rows": {+ "screen": {+ "name": "画面とシステムオーディオ",+ "description": "画面と Mac のサウンドを録画するため。"+ },+ "accessibility": {+ "name": "アクセシビリティ",+ "description": "録画に正しいカーソル(矢印、テキスト)を表示するため。"+ },+ "microphone": {+ "name": "マイク",+ "description": "声を録音するため。"+ },+ "camera": {+ "name": "カメラ",+ "description": "録画に Web カメラを追加するため。"+ }+ },+ "status": {+ "granted": "許可済み",+ "restricted": "組織によって管理されています"+ },+ "actions": {+ "continue": "続ける",+ "allow": "許可",+ "openSettings": "設定を開く",+ "restart": "OpenScreen を再起動",+ "start": "はじめる"+ },+ "help": {+ "screenPrompt": "このあと macOS から、システム設定で OpenScreen をオンにするよう求められます。",+ "screenSettings": "システム設定で OpenScreen をオンにしてください。macOS が終了して再度開くよう提案した場合は、そのまま進めてください。このウインドウが再び表示されます。",+ "screenNotListed": "リストに OpenScreen がない場合は、+をクリックして「アプリケーション」から OpenScreen を選んでください。",+ "screenRestart": "許可済みです。使用するには OpenScreen の再起動が必要です。",+ "screenRecurring": "macOS からときどきこのアクセスの確認を求められます。これは正常な動作です。"+ },+ "footer": {+ "screenRequired": "録画には画面収録が必要です。",+ "ready": "準備が整いました。"+ }}}diff --git a/src/i18n/locales/ko-KR/common.json b/src/i18n/locales/ko-KR/common.jsonindex c9ddd9ba7..c83e9c634 100644--- a/src/i18n/locales/ko-KR/common.json+++ b/src/i18n/locales/ko-KR/common.json@@ -45,7 +45,8 @@"hide": "OpenScreen 숨기기","hideOthers": "다른 항목 숨기기","unhide": "모두 보기",- "saveDiagnostics": "진단 정보 저장"+ "saveDiagnostics": "진단 정보 저장",+ "permissions": "권한…"},"updates": {"available": "OpenScreen {{latestVersion}} 버전을 사용할 수 있습니다. 현재 버전은 {{currentVersion}}입니다.",diff --git a/src/i18n/locales/ko-KR/launch.json b/src/i18n/locales/ko-KR/launch.jsonindex 192089224..2e2abe3e9 100644--- a/src/i18n/locales/ko-KR/launch.json+++ b/src/i18n/locales/ko-KR/launch.json@@ -95,5 +95,54 @@"about": "정보","version": "버전 {{version}}","checkingForUpdates": "확인 중…"+ },+ "permissions": {+ "title": "OpenScreen에 몇 가지 권한이 필요합니다",+ "subtitle": "macOS에서는 각 권한을 한 번만 허용하면 됩니다. 시스템 설정에서 언제든지 변경할 수 있습니다.",+ "level": {+ "required": "필수",+ "recommended": "권장",+ "optional": "선택"+ },+ "rows": {+ "screen": {+ "name": "화면 및 시스템 오디오",+ "description": "화면과 Mac의 소리를 녹화하기 위해 필요합니다."+ },+ "accessibility": {+ "name": "손쉬운 사용",+ "description": "녹화에 올바른 커서(화살표, 텍스트)를 표시하기 위해 필요합니다."+ },+ "microphone": {+ "name": "마이크",+ "description": "목소리를 녹음하기 위해 필요합니다."+ },+ "camera": {+ "name": "카메라",+ "description": "녹화에 웹캠을 추가하기 위해 필요합니다."+ }+ },+ "status": {+ "granted": "허용됨",+ "restricted": "조직에서 관리함"+ },+ "actions": {+ "continue": "계속",+ "allow": "허용",+ "openSettings": "설정 열기",+ "restart": "OpenScreen 재시작",+ "start": "시작하기"+ },+ "help": {+ "screenPrompt": "이어서 macOS가 시스템 설정에서 OpenScreen을 켜도록 요청합니다.",+ "screenSettings": "시스템 설정에서 OpenScreen을 켜세요. macOS가 종료 후 다시 열기를 제안하면 수락하세요. 이 창이 다시 표시됩니다.",+ "screenNotListed": "목록에 OpenScreen이 없나요? +를 클릭한 다음 응용 프로그램에서 OpenScreen을 선택하세요.",+ "screenRestart": "허용되었습니다. 이 권한을 사용하려면 OpenScreen을 재시작해야 합니다.",+ "screenRecurring": "macOS가 가끔 이 접근 권한을 확인하도록 요청합니다. 정상적인 동작입니다."+ },+ "footer": {+ "screenRequired": "녹화하려면 화면 기록 권한이 필요합니다.",+ "ready": "모든 준비가 끝났습니다."+ }}}diff --git a/src/i18n/locales/pt-BR/common.json b/src/i18n/locales/pt-BR/common.jsonindex 15c673daf..f0b86df0d 100644--- a/src/i18n/locales/pt-BR/common.json+++ b/src/i18n/locales/pt-BR/common.json@@ -45,7 +45,8 @@"hide": "Ocultar OpenScreen","hideOthers": "Ocultar Outros","unhide": "Mostrar Todos",- "saveDiagnostics": "Salvar Diagnósticos"+ "saveDiagnostics": "Salvar Diagnósticos",+ "permissions": "Permissões…"},"updates": {"available": "O OpenScreen {{latestVersion}} está disponível. Você está usando a versão {{currentVersion}}.",diff --git a/src/i18n/locales/pt-BR/launch.json b/src/i18n/locales/pt-BR/launch.jsonindex 4d1fc9270..5cc6d8407 100644--- a/src/i18n/locales/pt-BR/launch.json+++ b/src/i18n/locales/pt-BR/launch.json@@ -95,5 +95,54 @@"about": "Sobre","version": "Versão {{version}}","checkingForUpdates": "Verificando…"+ },+ "permissions": {+ "title": "O OpenScreen precisa de algumas permissões",+ "subtitle": "O macOS pede que você conceda cada uma apenas uma vez. Você pode alterá-las a qualquer momento nos Ajustes do Sistema.",+ "level": {+ "required": "Obrigatória",+ "recommended": "Recomendada",+ "optional": "Opcional"+ },+ "rows": {+ "screen": {+ "name": "Tela e áudio do sistema",+ "description": "Para gravar sua tela e o som do seu Mac."+ },+ "accessibility": {+ "name": "Acessibilidade",+ "description": "Para mostrar o cursor certo (seta, texto) nas suas gravações."+ },+ "microphone": {+ "name": "Microfone",+ "description": "Para gravar sua voz."+ },+ "camera": {+ "name": "Câmera",+ "description": "Para adicionar sua webcam às gravações."+ }+ },+ "status": {+ "granted": "Permitido",+ "restricted": "Gerenciado pela sua organização"+ },+ "actions": {+ "continue": "Continuar",+ "allow": "Permitir",+ "openSettings": "Abrir Ajustes",+ "restart": "Reiniciar o OpenScreen",+ "start": "Começar"+ },+ "help": {+ "screenPrompt": "Em seguida, o macOS pedirá que você ative o OpenScreen nos Ajustes do Sistema.",+ "screenSettings": "Nos Ajustes do Sistema, ative o OpenScreen. Se o macOS oferecer encerrar e reabrir o app, aceite: esta janela voltará.",+ "screenNotListed": "O OpenScreen não está na lista? Clique em + e escolha o OpenScreen em Aplicativos.",+ "screenRestart": "Permitido. O OpenScreen precisa reiniciar para usá-la.",+ "screenRecurring": "De vez em quando, o macOS pedirá que você confirme este acesso. Isso é normal."+ },+ "footer": {+ "screenRequired": "A gravação de tela é necessária para gravar.",+ "ready": "Tudo pronto."+ }}}diff --git a/src/i18n/locales/ru/common.json b/src/i18n/locales/ru/common.jsonindex 67411840b..5abfda0f3 100644--- a/src/i18n/locales/ru/common.json+++ b/src/i18n/locales/ru/common.json@@ -45,7 +45,8 @@"hide": "Скрыть OpenScreen","hideOthers": "Скрыть остальные","unhide": "Показать все",- "saveDiagnostics": "Сохранить диагностику"+ "saveDiagnostics": "Сохранить диагностику",+ "permissions": "Разрешения…"},"updates": {"available": "Доступен OpenScreen {{latestVersion}}. Установлена версия {{currentVersion}}.",diff --git a/src/i18n/locales/ru/launch.json b/src/i18n/locales/ru/launch.jsonindex 0af9564c4..0fadfb5f4 100644--- a/src/i18n/locales/ru/launch.json+++ b/src/i18n/locales/ru/launch.json@@ -95,5 +95,54 @@"about": "О программе","version": "Версия {{version}}","checkingForUpdates": "Проверка…"+ },+ "permissions": {+ "title": "OpenScreen нужны некоторые разрешения",+ "subtitle": "macOS запрашивает каждое разрешение только один раз. Их можно изменить в любой момент в Системных настройках.",+ "level": {+ "required": "Обязательно",+ "recommended": "Рекомендуется",+ "optional": "Необязательно"+ },+ "rows": {+ "screen": {+ "name": "Экран и системный звук",+ "description": "Чтобы записывать экран и звук вашего Mac."+ },+ "accessibility": {+ "name": "Универсальный доступ",+ "description": "Чтобы в записях отображался правильный курсор (стрелка, текст)."+ },+ "microphone": {+ "name": "Микрофон",+ "description": "Чтобы записывать ваш голос."+ },+ "camera": {+ "name": "Камера",+ "description": "Чтобы добавлять веб-камеру в записи."+ }+ },+ "status": {+ "granted": "Разрешено",+ "restricted": "Управляется вашей организацией"+ },+ "actions": {+ "continue": "Продолжить",+ "allow": "Разрешить",+ "openSettings": "Открыть настройки",+ "restart": "Перезапустить OpenScreen",+ "start": "Начать"+ },+ "help": {+ "screenPrompt": "Затем macOS попросит включить OpenScreen в Системных настройках.",+ "screenSettings": "Включите OpenScreen в Системных настройках. Если macOS предложит закрыть и снова открыть приложение, согласитесь: это окно вернётся.",+ "screenNotListed": "OpenScreen нет в списке? Нажмите «+» и выберите OpenScreen в папке «Программы».",+ "screenRestart": "Разрешено. OpenScreen нужно перезапустить, чтобы использовать это разрешение.",+ "screenRecurring": "Время от времени macOS будет просить подтвердить этот доступ. Это нормально."+ },+ "footer": {+ "screenRequired": "Для записи нужна запись экрана.",+ "ready": "Всё готово."+ }}}diff --git a/src/i18n/locales/tr/common.json b/src/i18n/locales/tr/common.jsonindex a5bb28a32..b082906bf 100644--- a/src/i18n/locales/tr/common.json+++ b/src/i18n/locales/tr/common.json@@ -45,7 +45,8 @@"hide": "OpenScreen’i Gizle","hideOthers": "Diğerlerini Gizle","unhide": "Tümünü Göster",- "saveDiagnostics": "Teşhis Verilerini Kaydet"+ "saveDiagnostics": "Teşhis Verilerini Kaydet",+ "permissions": "İzinler…"},"updates": {"available": "OpenScreen {{latestVersion}} kullanılabilir. Mevcut sürümünüz {{currentVersion}}.",diff --git a/src/i18n/locales/tr/launch.json b/src/i18n/locales/tr/launch.jsonindex 632709c82..eb7c2f3b1 100644--- a/src/i18n/locales/tr/launch.json+++ b/src/i18n/locales/tr/launch.json@@ -95,5 +95,54 @@"about": "Hakkında","version": "Sürüm {{version}}","checkingForUpdates": "Denetleniyor…"+ },+ "permissions": {+ "title": "OpenScreen'in birkaç izne ihtiyacı var",+ "subtitle": "macOS her birini yalnızca bir kez ister. Bunları istediğiniz zaman Sistem Ayarları'ndan değiştirebilirsiniz.",+ "level": {+ "required": "Gerekli",+ "recommended": "Önerilen",+ "optional": "İsteğe bağlı"+ },+ "rows": {+ "screen": {+ "name": "Ekran ve sistem sesi",+ "description": "Ekranınızı ve Mac'inizin sesini kaydetmek için."+ },+ "accessibility": {+ "name": "Erişilebilirlik",+ "description": "Kayıtlarınızda doğru imleci (ok, metin) göstermek için."+ },+ "microphone": {+ "name": "Mikrofon",+ "description": "Sesinizi kaydetmek için."+ },+ "camera": {+ "name": "Kamera",+ "description": "Web kameranızı kayıtlarınıza eklemek için."+ }+ },+ "status": {+ "granted": "İzin verildi",+ "restricted": "Kuruluşunuz tarafından yönetiliyor"+ },+ "actions": {+ "continue": "Devam",+ "allow": "İzin ver",+ "openSettings": "Ayarları Aç",+ "restart": "OpenScreen'i yeniden başlat",+ "start": "Başla"+ },+ "help": {+ "screenPrompt": "Ardından macOS, Sistem Ayarları'nda OpenScreen'i açmanızı isteyecek.",+ "screenSettings": "Sistem Ayarları'nda OpenScreen'i açın. macOS uygulamayı kapatıp yeniden açmayı önerirse kabul edin: bu pencere geri gelecek.",+ "screenNotListed": "OpenScreen listede yok mu? + düğmesine tıklayın ve Uygulamalar'dan OpenScreen'i seçin.",+ "screenRestart": "İzin verildi. OpenScreen'in bunu kullanabilmesi için yeniden başlatılması gerekiyor.",+ "screenRecurring": "macOS zaman zaman bu erişimi onaylamanızı isteyecek. Bu normaldir."+ },+ "footer": {+ "screenRequired": "Kayıt için ekran kaydı gereklidir.",+ "ready": "Her şey hazır."+ }}}diff --git a/src/i18n/locales/vi/common.json b/src/i18n/locales/vi/common.jsonindex 0d4cc878b..d55b90865 100644--- a/src/i18n/locales/vi/common.json+++ b/src/i18n/locales/vi/common.json@@ -45,7 +45,8 @@"hide": "Ẩn OpenScreen","hideOthers": "Ẩn ứng dụng khác","unhide": "Hiển thị tất cả",- "saveDiagnostics": "Lưu thông tin chẩn đoán"+ "saveDiagnostics": "Lưu thông tin chẩn đoán",+ "permissions": "Quyền…"},"updates": {"available": "Đã có OpenScreen {{latestVersion}}. Bạn đang dùng phiên bản {{currentVersion}}.",diff --git a/src/i18n/locales/vi/launch.json b/src/i18n/locales/vi/launch.jsonindex 98405bf99..9775e4622 100644--- a/src/i18n/locales/vi/launch.json+++ b/src/i18n/locales/vi/launch.json@@ -95,5 +95,54 @@"about": "Giới thiệu","version": "Phiên bản {{version}}","checkingForUpdates": "Đang kiểm tra…"+ },+ "permissions": {+ "title": "OpenScreen cần một vài quyền",+ "subtitle": "macOS chỉ yêu cầu bạn cấp mỗi quyền một lần. Bạn có thể thay đổi bất cứ lúc nào trong Cài đặt hệ thống.",+ "level": {+ "required": "Bắt buộc",+ "recommended": "Nên dùng",+ "optional": "Tùy chọn"+ },+ "rows": {+ "screen": {+ "name": "Màn hình & âm thanh hệ thống",+ "description": "Để ghi màn hình và âm thanh của máy Mac."+ },+ "accessibility": {+ "name": "Trợ năng",+ "description": "Để hiển thị đúng con trỏ (mũi tên, văn bản) trong bản ghi."+ },+ "microphone": {+ "name": "Micrô",+ "description": "Để ghi giọng nói của bạn."+ },+ "camera": {+ "name": "Camera",+ "description": "Để thêm webcam vào bản ghi."+ }+ },+ "status": {+ "granted": "Đã cho phép",+ "restricted": "Do tổ chức của bạn quản lý"+ },+ "actions": {+ "continue": "Tiếp tục",+ "allow": "Cho phép",+ "openSettings": "Mở Cài đặt",+ "restart": "Khởi động lại OpenScreen",+ "start": "Bắt đầu"+ },+ "help": {+ "screenPrompt": "Sau đó macOS sẽ yêu cầu bạn bật OpenScreen trong Cài đặt hệ thống.",+ "screenSettings": "Trong Cài đặt hệ thống, hãy bật OpenScreen. Nếu macOS đề nghị thoát và mở lại, hãy đồng ý: cửa sổ này sẽ quay lại.",+ "screenNotListed": "Không thấy OpenScreen trong danh sách? Bấm +, rồi chọn OpenScreen trong Ứng dụng.",+ "screenRestart": "Đã cho phép. OpenScreen cần khởi động lại để sử dụng quyền này.",+ "screenRecurring": "Thỉnh thoảng macOS sẽ yêu cầu bạn xác nhận quyền truy cập này. Điều đó là bình thường."+ },+ "footer": {+ "screenRequired": "Cần quyền ghi màn hình để ghi.",+ "ready": "Mọi thứ đã sẵn sàng."+ }}}diff --git a/src/i18n/locales/zh-CN/common.json b/src/i18n/locales/zh-CN/common.jsonindex e789cbd5b..1c603d9e3 100644--- a/src/i18n/locales/zh-CN/common.json+++ b/src/i18n/locales/zh-CN/common.json@@ -45,7 +45,8 @@"hide": "隐藏 OpenScreen","hideOthers": "隐藏其他","unhide": "显示全部",- "saveDiagnostics": "保存诊断信息"+ "saveDiagnostics": "保存诊断信息",+ "permissions": "权限…"},"updates": {"available": "OpenScreen {{latestVersion}} 已发布。当前版本为 {{currentVersion}}。",diff --git a/src/i18n/locales/zh-CN/launch.json b/src/i18n/locales/zh-CN/launch.jsonindex e7efe8eec..3e01503fe 100644--- a/src/i18n/locales/zh-CN/launch.json+++ b/src/i18n/locales/zh-CN/launch.json@@ -95,5 +95,54 @@"about": "关于","version": "版本 {{version}}","checkingForUpdates": "正在检查…"+ },+ "permissions": {+ "title": "OpenScreen 需要一些权限",+ "subtitle": "macOS 只会请求你授予一次。你可以随时在“系统设置”中更改。",+ "level": {+ "required": "必需",+ "recommended": "推荐",+ "optional": "可选"+ },+ "rows": {+ "screen": {+ "name": "屏幕与系统音频",+ "description": "用于录制你的屏幕和 Mac 播放的声音。"+ },+ "accessibility": {+ "name": "辅助功能",+ "description": "用于在录制中显示正确的光标(箭头、文本)。"+ },+ "microphone": {+ "name": "麦克风",+ "description": "用于录制你的声音。"+ },+ "camera": {+ "name": "摄像头",+ "description": "用于在录制中加入你的网络摄像头。"+ }+ },+ "status": {+ "granted": "已允许",+ "restricted": "由你的组织管理"+ },+ "actions": {+ "continue": "继续",+ "allow": "允许",+ "openSettings": "打开设置",+ "restart": "重新启动 OpenScreen",+ "start": "开始使用"+ },+ "help": {+ "screenPrompt": "接下来 macOS 会请你在“系统设置”中开启 OpenScreen。",+ "screenSettings": "请在“系统设置”中开启 OpenScreen。如果 macOS 提示退出并重新打开,请同意:此窗口会重新出现。",+ "screenNotListed": "列表中没有 OpenScreen?点按 +,然后在“应用程序”中选择 OpenScreen。",+ "screenRestart": "已允许。OpenScreen 需要重新启动才能使用。",+ "screenRecurring": "macOS 会不时请你确认此访问权限,这是正常现象。"+ },+ "footer": {+ "screenRequired": "录制需要屏幕录制权限。",+ "ready": "一切就绪。"+ }}}diff --git a/src/i18n/locales/zh-TW/common.json b/src/i18n/locales/zh-TW/common.jsonindex 8e3d0648c..f003532b1 100644--- a/src/i18n/locales/zh-TW/common.json+++ b/src/i18n/locales/zh-TW/common.json@@ -45,7 +45,8 @@"hide": "隱藏 OpenScreen","hideOthers": "隱藏其他","unhide": "全部顯示",- "saveDiagnostics": "儲存診斷資料"+ "saveDiagnostics": "儲存診斷資料",+ "permissions": "權限…"},"updates": {"available": "OpenScreen {{latestVersion}} 已推出。目前版本為 {{currentVersion}}。",diff --git a/src/i18n/locales/zh-TW/launch.json b/src/i18n/locales/zh-TW/launch.jsonindex 025e422e7..db01e620f 100644--- a/src/i18n/locales/zh-TW/launch.json+++ b/src/i18n/locales/zh-TW/launch.json@@ -95,5 +95,54 @@"about": "關於","version": "版本 {{version}}","checkingForUpdates": "檢查中…"+ },+ "permissions": {+ "title": "OpenScreen 需要一些權限",+ "subtitle": "macOS 只會請你授予一次。你可以隨時在「系統設定」中更改。",+ "level": {+ "required": "必要",+ "recommended": "建議",+ "optional": "選用"+ },+ "rows": {+ "screen": {+ "name": "螢幕與系統音訊",+ "description": "用於錄製你的螢幕與 Mac 播放的聲音。"+ },+ "accessibility": {+ "name": "輔助使用",+ "description": "用於在錄製中顯示正確的游標(箭頭、文字)。"+ },+ "microphone": {+ "name": "麥克風",+ "description": "用於錄製你的聲音。"+ },+ "camera": {+ "name": "相機",+ "description": "用於在錄製中加入你的網路攝影機。"+ }+ },+ "status": {+ "granted": "已允許",+ "restricted": "由你的組織管理"+ },+ "actions": {+ "continue": "繼續",+ "allow": "允許",+ "openSettings": "打開設定",+ "restart": "重新啟動 OpenScreen",+ "start": "開始使用"+ },+ "help": {+ "screenPrompt": "接下來 macOS 會請你在「系統設定」中開啟 OpenScreen。",+ "screenSettings": "請在「系統設定」中開啟 OpenScreen。如果 macOS 提議結束並重新打開,請同意:此視窗會再次出現。",+ "screenNotListed": "列表中沒有 OpenScreen?按一下 +,然後在「應用程式」中選擇 OpenScreen。",+ "screenRestart": "已允許。OpenScreen 需要重新啟動才能使用。",+ "screenRecurring": "macOS 會不時請你確認此存取權限,這是正常的。"+ },+ "footer": {+ "screenRequired": "錄製需要螢幕錄製權限。",+ "ready": "一切就緒。"+ }}}