Add .isAccessGranted() method

.gitignore

@@ -3,3 +3,4 @@ yarn.lock
 /.build
 /*.xcodeproj
 /main
+/is-access-granted

Package.swift

@@ -4,6 +4,7 @@ import PackageDescription
 let package = Package(
 	name: "active-win",
 	targets: [
-		.target(name: "active-win")
+		.target(name: "active-win"),
+		.target(name: "is-access-granted")
 	]
 )

Sources/is-access-granted/main.swift

@@ -0,0 +1,19 @@
+/* Executable that will return a JSON with the granted permissions:
+ *  {
+ * 		"isAccessibilityGranted": boolean
+ * 		"isScreenRecordingGranted": boolean
+ *	}
+ *  
+ */
+
+import AppKit
+
+var dictionary: [String: Any] = [
+  "isAccessibilityGranted": AXIsProcessTrustedWithOptions(
+    ["AXTrustedCheckOptionPrompt": false] as CFDictionary),
+  "isScreenRecordingGranted": isScreenRecordingGrantedNoDialog()
+]
+
+print(try! toJson(dictionary))
+
+exit(0)

Sources/is-access-granted/utilities.swift

@@ -0,0 +1,59 @@
+import AppKit
+
+func toJson<T>(_ data: T) throws -> String {
+	let json = try JSONSerialization.data(withJSONObject: data)
+	return String(decoding: json, as: UTF8.self)
+}
+
+/**
+ *  Returns true if the Screen recording is granted by the user for this app. False
+ *  otherwise.
+ *	This method will not prompt the user with a dialog to grant permissions
+ *  CREDITS: https://gist.github.com/soffes/da6ea98be4f56bc7b8e75079a5224b37
+ */
+func isScreenRecordingGrantedNoDialog() -> Bool {
+  // The screen recording security was introduced in version 10.15 of MAC os
+  if #available(macOS 10.15, *) {
+    let runningApplication = NSRunningApplication.current
+    let processIdentifier = runningApplication.processIdentifier
+
+    guard let windows = CGWindowListCopyWindowInfo([.optionOnScreenOnly], kCGNullWindowID)
+      as? [[String: AnyObject]] else
+    {
+      assertionFailure("Invalid window info")
+      return false
+    }
+
+    for window in windows {
+      // Get information for each window
+      guard let windowProcessIdentifier = (window[String(kCGWindowOwnerPID)] as? Int).flatMap(pid_t.init) else {
+        assertionFailure("Invalid window info")
+        continue
+      }
+
+      // Don't check windows owned by this process
+      if windowProcessIdentifier == processIdentifier {
+        continue
+      }
+
+      // Get process information for each window
+      guard let windowRunningApplication = NSRunningApplication(processIdentifier: windowProcessIdentifier) else {
+        // Ignore processes we don't have access to, such as WindowServer, which manages the windows named
+        // "Menubar" and "Backstop Menubar"
+        continue
+      }
+
+      if window[String(kCGWindowName)] as? String != nil {
+        if windowRunningApplication.executableURL?.lastPathComponent == "Dock" {
+          // Ignore the Dock, which provides the desktop picture
+          continue
+        } else {
+          return true
+        }
+      }
+    }
+    return false
+  } else {
+    return true;
+  }
+}

index.d.ts

@@ -76,7 +76,26 @@ declare namespace activeWin {
 		platform: 'windows';
 	}
 
+	interface BaseAccessResult {
+		all: boolean;
+	}
+
+	interface MacOSAccessResult extends BaseAccessResult {
+		screen: boolean;
+		accessibility: boolean;
+		platform: 'macos';
+	}
+
+	interface WindowsAccessResult extends BaseAccessResult {
+		platform: 'windows';
+	}
+
+	interface LinuxAccessResult extends BaseAccessResult {
+		platform: 'linux';
+	}
+
 	type Result = MacOSResult | LinuxResult | WindowsResult;
+	type AccessResult = MacOSAccessResult | LinuxAccessResult | WindowsAccessResult;
 }
 
 declare const activeWin: {
@@ -133,6 +152,13 @@ declare const activeWin: {
 	```
 	*/
 	sync(): activeWin.Result | undefined;
+
+	/**
+	Checks if the app has enough access to get the active window
+	Returns true if there is enough access, false otherwise
+	To prompt user with a dialog to give access call activeWin() or activeWin.sync()
+	*/
+	isAccessGranted(): activeWin.AccessResult;
 };
 
 export = activeWin;

index.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const PLATFORM_NOT_RECOGNIZED_ERROR = 'macOS, Linux, and Windows only';
+
 module.exports = () => {
 	if (process.platform === 'darwin') {
 		return require('./lib/macos')();
@@ -13,7 +15,7 @@ module.exports = () => {
 		return require('./lib/windows')();
 	}
 
-	return Promise.reject(new Error('macOS, Linux, and Windows only'));
+	return Promise.reject(new Error(PLATFORM_NOT_RECOGNIZED_ERROR));
 };
 
 module.exports.sync = () => {
@@ -29,5 +31,37 @@ module.exports.sync = () => {
 		return require('./lib/windows').sync();
 	}
 
-	throw new Error('macOS, Linux, and Windows only');
+	throw new Error(PLATFORM_NOT_RECOGNIZED_ERROR);
+};
+
+module.exports.isAccessGranted = () => {
+	switch (process.platform) {
+		case 'darwin': {
+			// MAC OS needs specific accesses to get the active window. These accesses are
+			// resolved by the isAccessGranted method of the macos lib
+			const result = require('./lib/macos').isAccessGranted();
+			result.platform = 'macos';
+			return result;
+		}
+
+		case 'linux': {
+			// Linux does not need specific access to get the active window
+			return {
+				platform: 'linux',
+				all: true
+			};
+		}
+
+		// Windows does not need specific access to get the active window
+		case 'win32': {
+			return {
+				patform: 'windows',
+				all: true
+			};
+		}
+
+		default: {
+			throw new Error(PLATFORM_NOT_RECOGNIZED_ERROR);
+		}
+	}
 };

lib/macos.js

@@ -4,7 +4,8 @@ const {promisify} = require('util');
 const childProcess = require('child_process');
 
 const execFile = promisify(childProcess.execFile);
-const bin = path.join(__dirname, '../main');
+const activeWinBin = path.join(__dirname, '../main');
+const isAccessGrantedBin = path.join(__dirname, '../is-access-granted');
 
 const parseMac = stdout => {
 	try {
@@ -19,9 +20,26 @@ const parseMac = stdout => {
 	}
 };
 
+const isAccessGranted = () => {
+	let result = childProcess.execFileSync(isAccessGrantedBin);
+	try {
+		result = JSON.parse(result);
+	} catch (error) {
+		console.error(error);
+		throw new Error('Error parsing access granted data');
+	}
+
+	return {
+		all: result.isAccessibilityGranted && result.isScreenRecordingGranted,
+		screen: result.isScreenRecordingGranted,
+		accessibility: result.isAccessibilityGranted
+	};
+};
+
 module.exports = async () => {
-	const {stdout} = await execFile(bin);
+	const {stdout} = await execFile(activeWinBin);
 	return parseMac(stdout);
 };
 
-module.exports.sync = () => parseMac(childProcess.execFileSync(bin, {encoding: 'utf8'}));
+module.exports.sync = () => parseMac(childProcess.execFileSync(activeWinBin, {encoding: 'utf8'}));
+module.exports.isAccessGranted = isAccessGranted;

package.json

@@ -15,14 +15,15 @@
 	},
 	"scripts": {
 		"test": "xo && ava && tsd",
-		"build": "swift build --configuration=release && mv .build/release/active-win main",
+		"build": "swift build --configuration=release && mv .build/release/active-win main && mv .build/release/is-access-granted is-access-granted",
 		"prepublishOnly": "npm run build"
 	},
 	"files": [
 		"index.js",
 		"index.d.ts",
 		"lib",
-		"main"
+		"main",
+		"is-access-granted"
 	],
 	"keywords": [
 		"macos",

readme.md

@@ -71,6 +71,14 @@ Returns an `Object` with the result, or `undefined` if there is no active window
 - `url` *(string?)* - URL of the active browser tab if the active window is Safari, Chrome, Edge, or Brave *(macOS only)*
 - `memoryUsage` *(number)* - Memory usage by the window owner process
 
+### activeWin.isAccessGranted()
+
+Check if the package has enough access to get the active window.
+
+Returns `true` if there is enough access, `false` otherwise.
+
+To prompt the user with a dialog to give access, call `activeWin()` or `activeWin.sync()`.
+
 ## OS support
 
 It works on macOS, Linux, and Windows 7+.

test.js

@@ -18,3 +18,31 @@ test('async', async t => {
 test('sync', t => {
 	asserter(t, activeWin.sync());
 });
+
+test('isAccessGranted', t => {
+	const result = activeWin.isAccessGranted();
+	switch (process.platform) {
+		case 'darwin': {
+			t.is(result.platform, 'macos');
+			t.is(typeof result.screen, 'boolean');
+			t.is(typeof result.accessibility, 'boolean');
+			break;
+		}
+
+		case 'linux': {
+			t.is(result.platform, 'linux');
+			break;
+		}
+
+		case 'win32': {
+			t.is(result.platform, 'windows');
+			break;
+		}
+
+		default: {
+			throw new Error('Platform not recognized');
+		}
+	}
+
+	t.is(typeof result.all, 'boolean');
+});