@macify/xpc 0.0.2 → 0.0.4

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require("./plugin/build/index.cjs");

package/build/index.d.cts

@@ -0,0 +1,33 @@
+//#region src/index.d.ts
+type EventHandler = (data: any) => void;
+/**
+ * Client API for communicating with the XPC service.
+ */
+declare const macx: {
+  /**
+   * Call the XPC service with an RPC message.
+   * @param type - The message type (e.g. "ping", "processImage")
+   * @param payload - The payload object (will be JSON-serialized)
+   * @returns The response from the XPC service
+   */
+  call<T = any>(type: string, payload?: Record<string, any>): Promise<T>;
+  /**
+   * Listen for events pushed from the XPC service, or connection state changes.
+   *
+   * XPC events: `macx.on("progress", (data) => { ... })`
+   * Connection state: `macx.on("connectionLost", () => { ... })`
+   *                   `macx.on("connectionRestored", () => { ... })`
+   *
+   * @param type - The event type to listen for
+   * @param handler - Callback invoked with the event payload
+   * @returns Unsubscribe function
+   */
+  on(type: string, handler: EventHandler): () => void;
+  /**
+   * Remove all listeners for a specific event type.
+   * For fine-grained control, use the unsubscribe function returned by `on()`.
+   */
+  off(type: string): void;
+};
+//#endregion
+export { macx };

package/expo-module.config.json

@@ -0,0 +1,6 @@
+{
+  "platforms": ["apple"],
+  "apple": {
+    "modules": ["MacifyXPCModule"]
+  }
+}

package/ios/MacifyServiceClient.swift

@@ -0,0 +1,152 @@
+import Foundation
+
+/// Client that connects to the XPC service from the main app process.
+/// Provides generic JSON RPC and receives events from the XPC service.
+class MacifyServiceClient: NSObject, MacifyXPCEventReceiver {
+    static let shared = MacifyServiceClient()
+
+    private var connection: NSXPCConnection?
+    private var serviceName: String?
+    private var isConnected = false
+
+    /// Callback for events received from the XPC service.
+    /// Set by MacifyXPCModule to bridge events to JS.
+    var onEvent: ((String, [String: Any]) -> Void)?
+
+    /// Callback for connection state changes (lost/restored).
+    /// Set by MacifyXPCModule to bridge connection events to JS.
+    var onConnectionStateChange: ((ConnectionState) -> Void)?
+
+    enum ConnectionState {
+        case lost
+        case restored
+    }
+
+    /// Configure the service name. Called once from MacifyXPCModule on init.
+    func configure(serviceName: String) {
+        self.serviceName = serviceName
+    }
+
+    private func getConnection() -> NSXPCConnection? {
+        if let existing = connection {
+            return existing
+        }
+
+        guard let name = serviceName else {
+            return nil
+        }
+
+        // NSXPCConnection(serviceName:) is unavailable in Mac Catalyst Swift headers,
+        // but the API exists at runtime on macOS. We use an ObjC bridge to bypass
+        // the compile-time availability check.
+        let conn = XPCConnectionFactory.connection(withServiceName: name)
+
+        // Interface the XPC service exports (we call it)
+        conn.remoteObjectInterface = NSXPCInterface(
+            with: MacifyXPCProtocol.self
+        )
+
+        // Interface we export (XPC service calls us for events)
+        conn.exportedInterface = NSXPCInterface(
+            with: MacifyXPCEventReceiver.self
+        )
+        conn.exportedObject = self
+
+        conn.invalidationHandler = { [weak self] in
+            guard let self = self else { return }
+            self.connection = nil
+            if self.isConnected {
+                self.isConnected = false
+                self.onConnectionStateChange?(.lost)
+            }
+        }
+
+        conn.interruptionHandler = { [weak self] in
+            guard let self = self else { return }
+            self.connection = nil
+            if self.isConnected {
+                self.isConnected = false
+                self.onConnectionStateChange?(.lost)
+            }
+        }
+
+        conn.resume()
+        connection = conn
+        isConnected = true
+
+        return conn
+    }
+
+    /// Generic RPC call to the XPC service.
+    func call(type: String, payload: [String: Any]) async throws -> [String: Any] {
+        guard let conn = getConnection() else {
+            throw NSError(
+                domain: "MacifyXPC",
+                code: -3,
+                userInfo: [NSLocalizedDescriptionKey: "XPC connection was lost — service name not configured"]
+            )
+        }
+
+        // If we're reconnecting after a lost connection, notify JS
+        if !isConnected {
+            isConnected = true
+            onConnectionStateChange?(.restored)
+        }
+
+        // Encode payload to JSON Data
+        let payloadData: Data
+        if payload.isEmpty {
+            payloadData = Data()
+        } else {
+            payloadData = try JSONSerialization.data(withJSONObject: payload, options: [])
+        }
+
+        return try await withCheckedThrowingContinuation { continuation in
+            let proxy = conn.remoteObjectProxyWithErrorHandler { error in
+                continuation.resume(throwing: error)
+            }
+            guard let service = proxy as? MacifyXPCProtocol else {
+                continuation.resume(
+                    throwing: NSError(
+                        domain: "MacifyXPC",
+                        code: -1,
+                        userInfo: [NSLocalizedDescriptionKey: "XPC connection was lost"]
+                    )
+                )
+                return
+            }
+
+            service.call(type: type, payload: payloadData) { responseData, error in
+                if let error = error {
+                    continuation.resume(throwing: error)
+                    return
+                }
+                guard let data = responseData else {
+                    continuation.resume(returning: [:])
+                    return
+                }
+                do {
+                    let result = try JSONSerialization.jsonObject(with: data, options: [])
+                    continuation.resume(returning: (result as? [String: Any]) ?? [:])
+                } catch {
+                    continuation.resume(throwing: error)
+                }
+            }
+        }
+    }
+
+    // MARK: - MacifyXPCEventReceiver
+
+    /// Called by the XPC service when it pushes an event to the app.
+    func handleEvent(type: String, payload: Data) {
+        let decoded: [String: Any]
+        if payload.isEmpty {
+            decoded = [:]
+        } else if let json = try? JSONSerialization.jsonObject(with: payload, options: []) as? [String: Any] {
+            decoded = json
+        } else {
+            decoded = [:]
+        }
+        onEvent?(type, decoded)
+    }
+}

package/ios/MacifyXPC.podspec

@@ -0,0 +1,18 @@
+Pod::Spec.new do |s|
+  s.name           = 'MacifyXPC'
+  s.version        = '0.0.1'
+  s.summary        = 'XPC service client for Mac Catalyst Expo apps'
+  s.description    = 'Provides XPC communication between React Native and a macOS XPC service'
+  s.homepage       = 'https://github.com/user/macify'
+  s.license        = 'MIT'
+  s.author         = 'Theo'
+  s.source         = { git: '' }
+
+  s.platform       = :ios, '15.1'
+  s.swift_version  = '5.9'
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  s.source_files   = '**/*.{h,m,swift}'
+end

package/ios/MacifyXPCModule.swift

@@ -0,0 +1,85 @@
+import ExpoModulesCore
+
+public class MacifyXPCModule: Module {
+    private var hasListeners = false
+
+    public func definition() -> ModuleDefinition {
+        Name("MacifyXPC")
+
+        // Read the service name from Info.plist (set by the config plugin)
+        OnCreate {
+            if let serviceName = Bundle.main.infoDictionary?["MacifyXPCServiceName"] as? String {
+                MacifyServiceClient.shared.configure(serviceName: serviceName)
+            }
+        }
+
+        // Only bridge events to JS when there are active listeners
+        OnStartObserving {
+            self.hasListeners = true
+
+            // Bridge XPC events to JS
+            MacifyServiceClient.shared.onEvent = { [weak self] type, payload in
+                guard let self = self, self.hasListeners else { return }
+                if let data = try? JSONSerialization.data(withJSONObject: payload, options: []),
+                   let jsonString = String(data: data, encoding: .utf8) {
+                    self.sendEvent("onXPCEvent", [
+                        "type": type,
+                        "payload": jsonString,
+                    ])
+                }
+            }
+
+            // Bridge connection state changes to JS
+            MacifyServiceClient.shared.onConnectionStateChange = { [weak self] state in
+                guard let self = self, self.hasListeners else { return }
+                switch state {
+                case .lost:
+                    self.sendEvent("onXPCConnectionState", [
+                        "type": "connectionLost",
+                        "payload": "",
+                    ])
+                case .restored:
+                    self.sendEvent("onXPCConnectionState", [
+                        "type": "connectionRestored",
+                        "payload": "",
+                    ])
+                }
+            }
+        }
+
+        OnStopObserving {
+            self.hasListeners = false
+            MacifyServiceClient.shared.onEvent = nil
+            MacifyServiceClient.shared.onConnectionStateChange = nil
+        }
+
+        Events("onXPCEvent", "onXPCConnectionState")
+
+        /// Generic RPC call to the XPC service.
+        /// Takes a type string and a JSON-encoded payload string.
+        /// Returns a JSON-encoded response string.
+        AsyncFunction("call") { (type: String, payloadJSON: String) -> String in
+            // Decode the JSON payload string into a dictionary
+            let payload: [String: Any]
+            if payloadJSON.isEmpty || payloadJSON == "{}" {
+                payload = [:]
+            } else {
+                guard let data = payloadJSON.data(using: .utf8),
+                      let decoded = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] else {
+                    throw NSError(
+                        domain: "MacifyXPC",
+                        code: -2,
+                        userInfo: [NSLocalizedDescriptionKey: "Invalid JSON payload"]
+                    )
+                }
+                payload = decoded
+            }
+
+            let result = try await MacifyServiceClient.shared.call(type: type, payload: payload)
+
+            // Encode response back to JSON string for JS
+            let responseData = try JSONSerialization.data(withJSONObject: result, options: [])
+            return String(data: responseData, encoding: .utf8) ?? "{}"
+        }
+    }
+}

package/ios/MacifyXPCProtocol.swift

@@ -0,0 +1,16 @@
+import Foundation
+
+/// Wire protocol for RPC calls from the app to the XPC service.
+/// This is the app-side copy — the XPC service has its own copy in the SPM package.
+@objc protocol MacifyXPCProtocol {
+    func call(
+        type: String,
+        payload: Data,
+        withReply reply: @escaping (Data?, NSError?) -> Void
+    )
+}
+
+/// Reverse channel: the XPC service pushes events back to the app.
+@objc protocol MacifyXPCEventReceiver {
+    func handleEvent(type: String, payload: Data)
+}

package/ios/XPCConnectionFactory.h

@@ -0,0 +1,14 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Bridges NSXPCConnection(serviceName:) which is unavailable in Mac Catalyst
+/// Swift headers. The API exists at runtime on macOS — it's only blocked at
+/// compile time because Catalyst uses the iOS SDK surface.
+@interface XPCConnectionFactory : NSObject
+
++ (NSXPCConnection *)connectionWithServiceName:(NSString *)serviceName;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/XPCConnectionFactory.m

@@ -0,0 +1,17 @@
+#import "XPCConnectionFactory.h"
+#import <objc/message.h>
+
+@implementation XPCConnectionFactory
+
++ (NSXPCConnection *)connectionWithServiceName:(NSString *)serviceName {
+    // NSXPCConnection(serviceName:) is marked API_UNAVAILABLE(ios) which
+    // blocks compilation in Mac Catalyst even though it exists at runtime.
+    // Use objc_msgSend to bypass the compile-time availability check.
+    NSXPCConnection *conn = [NSXPCConnection alloc];
+    NSXPCConnection *(*sendTyped)(id, SEL, NSString *) =
+        (NSXPCConnection *(*)(id, SEL, NSString *))objc_msgSend;
+    conn = sendTyped(conn, NSSelectorFromString(@"initWithServiceName:"), serviceName);
+    return conn;
+}
+
+@end

package/package.json

@@ -1,9 +1,18 @@
 {
   "name": "@macify/xpc",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "XPC service support for Mac Catalyst Expo apps",
   "main": "build/index.cjs",
   "types": "build/index.d.cts",
+  "files": [
+    "build/",
+    "plugin/build/",
+    "ios/",
+    "swift/Package.swift",
+    "swift/Sources/",
+    "app.plugin.js",
+    "expo-module.config.json"
+  ],
   "license": "MIT",
   "scripts": {
     "build": "tsdown"

package/plugin/build/index.cjs

@@ -0,0 +1,431 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let _expo_config_plugins = require("@expo/config-plugins");
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+
+//#region plugin/src/index.ts
+const XPC_PRODUCT_TYPE = "com.apple.product-type.xpc-service";
+const XPC_PRODUCT_FILE_TYPE = "wrapper.xpc-service";
+const SPM_PRODUCT_NAME = "MacifyXPCService";
+function getServiceName(config, props) {
+	if (props.serviceName) return props.serviceName;
+	return `${(config.name || "App").replace(/\s+/g, "")}Service`;
+}
+function getBundleId(config, serviceName) {
+	const appBundleId = config.ios?.bundleIdentifier;
+	if (!appBundleId) throw new Error("[xpc] No ios.bundleIdentifier set in Expo config. Required for XPC service.");
+	return `${appBundleId}.${serviceName}`;
+}
+/** Resolve the absolute path to @macify/xpc/swift/ */
+function resolveSwiftPackagePath() {
+	const swiftDir = node_path.default.resolve(__dirname, "../../swift");
+	if (!node_fs.default.existsSync(swiftDir)) throw new Error(`[xpc] Could not find Swift package at ${swiftDir}. Is @macify/xpc installed?`);
+	return swiftDir;
+}
+/** Find the user's xpc-sources directory */
+function findXPCSourcesDir(projectRoot) {
+	const xpcSourcesDir = node_path.default.join(projectRoot, "modules", "xpc-service", "xpc-sources");
+	if (!node_fs.default.existsSync(xpcSourcesDir)) throw new Error(`[xpc] Could not find XPC sources at ${xpcSourcesDir}. Run 'npx macx init' first.`);
+	return xpcSourcesDir;
+}
+const withXPCService = (config, props = {}) => {
+	const serviceName = getServiceName(config, props);
+	const bundleId = getBundleId(config, serviceName);
+	const macosTarget = props.macosDeploymentTarget || "13.0";
+	config = (0, _expo_config_plugins.withInfoPlist)(config, (config) => {
+		config.modResults.MacifyXPCServiceName = bundleId;
+		return config;
+	});
+	config = (0, _expo_config_plugins.withDangerousMod)(config, ["ios", async (config) => {
+		const iosDir = config.modRequest.platformProjectRoot;
+		const destDir = node_path.default.join(iosDir, serviceName);
+		const xpcSourcesDir = findXPCSourcesDir(config.modRequest.projectRoot);
+		if (node_fs.default.existsSync(destDir)) node_fs.default.rmSync(destDir, { recursive: true });
+		node_fs.default.mkdirSync(destDir, { recursive: true });
+		const files = node_fs.default.readdirSync(xpcSourcesDir);
+		for (const file of files) {
+			const src = node_path.default.join(xpcSourcesDir, file);
+			const dst = node_path.default.join(destDir, file);
+			if (node_fs.default.statSync(src).isFile()) node_fs.default.copyFileSync(src, dst);
+		}
+		console.log(`[xpc] Copied ${files.length} files to ios/${serviceName}/`);
+		return config;
+	}]);
+	config = (0, _expo_config_plugins.withXcodeProject)(config, async (config) => {
+		const project = config.modResults;
+		if (!config.ios?.appleTeamId) throw new Error("[xpc] No appleTeamId set in Expo config. Required for XPC service signing.");
+		const teamId = config.ios.appleTeamId;
+		if (project.pbxTargetByName(serviceName)) {
+			console.log(`[xpc] Target "${serviceName}" already exists, skipping.`);
+			return config;
+		}
+		const objects = project.hash.project.objects;
+		const swiftPackagePath = resolveSwiftPackagePath();
+		const iosDir = config.modRequest.platformProjectRoot;
+		const relativeSwiftPath = node_path.default.relative(iosDir, swiftPackagePath);
+		const spmRefUuid = project.generateUuid();
+		const spmRefSection = objects["XCLocalSwiftPackageReference"] || (objects["XCLocalSwiftPackageReference"] = {});
+		spmRefSection[spmRefUuid] = {
+			isa: "XCLocalSwiftPackageReference",
+			relativePath: `"${relativeSwiftPath}"`
+		};
+		spmRefSection[`${spmRefUuid}_comment`] = "XCLocalSwiftPackageReference \"MacifyXPCService\"";
+		const projectSection = project.pbxProjectSection();
+		for (const key of Object.keys(projectSection)) if (!key.endsWith("_comment")) {
+			const proj = projectSection[key];
+			if (!proj.packageReferences) proj.packageReferences = [];
+			proj.packageReferences.push({
+				value: spmRefUuid,
+				comment: "XCLocalSwiftPackageReference \"MacifyXPCService\""
+			});
+		}
+		const spmProductDepUuid = project.generateUuid();
+		const spmProductSection = objects["XCSwiftPackageProductDependency"] || (objects["XCSwiftPackageProductDependency"] = {});
+		spmProductSection[spmProductDepUuid] = {
+			isa: "XCSwiftPackageProductDependency",
+			package: spmRefUuid,
+			package_comment: "XCLocalSwiftPackageReference \"MacifyXPCService\"",
+			productName: SPM_PRODUCT_NAME
+		};
+		spmProductSection[`${spmProductDepUuid}_comment`] = SPM_PRODUCT_NAME;
+		const remoteProductDeps = [];
+		if (props.dependencies && props.dependencies.length > 0) {
+			const remoteRefSection = objects["XCRemoteSwiftPackageReference"] || (objects["XCRemoteSwiftPackageReference"] = {});
+			for (const dep of props.dependencies) {
+				if (!dep.version && !dep.exactVersion && !dep.branch) throw new Error(`[xpc] Remote dependency "${dep.url}" must specify one of: version, exactVersion, or branch.`);
+				let requirement;
+				if (dep.branch) requirement = {
+					kind: "branch",
+					branch: dep.branch
+				};
+				else if (dep.exactVersion) requirement = {
+					kind: "exactVersion",
+					version: dep.exactVersion
+				};
+				else requirement = {
+					kind: "upToNextMajorVersion",
+					minimumVersion: dep.version
+				};
+				const repoName = dep.url.replace(/\.git$/, "").split("/").pop() || dep.url;
+				const remoteRefUuid = project.generateUuid();
+				remoteRefSection[remoteRefUuid] = {
+					isa: "XCRemoteSwiftPackageReference",
+					repositoryURL: dep.url,
+					requirement
+				};
+				remoteRefSection[`${remoteRefUuid}_comment`] = `XCRemoteSwiftPackageReference "${repoName}"`;
+				for (const key of Object.keys(projectSection)) if (!key.endsWith("_comment")) projectSection[key].packageReferences.push({
+					value: remoteRefUuid,
+					comment: `XCRemoteSwiftPackageReference "${repoName}"`
+				});
+				for (const productName of dep.products) {
+					const productDepUuid = project.generateUuid();
+					spmProductSection[productDepUuid] = {
+						isa: "XCSwiftPackageProductDependency",
+						package: remoteRefUuid,
+						package_comment: `XCRemoteSwiftPackageReference "${repoName}"`,
+						productName
+					};
+					spmProductSection[`${productDepUuid}_comment`] = productName;
+					remoteProductDeps.push({
+						productDepUuid,
+						productName
+					});
+				}
+				console.log(`[xpc] Added remote SPM dependency: ${repoName} (${dep.products.join(", ")})`);
+			}
+		}
+		const sharedBuildSettings = {
+			SDKROOT: "macosx",
+			PRODUCT_NAME: `"$(TARGET_NAME)"`,
+			PRODUCT_BUNDLE_IDENTIFIER: `"${bundleId}"`,
+			INFOPLIST_FILE: `"${serviceName}/Info.plist"`,
+			SKIP_INSTALL: "YES",
+			MACOSX_DEPLOYMENT_TARGET: macosTarget,
+			DEVELOPMENT_TEAM: `"${teamId}"`,
+			CODE_SIGN_STYLE: "Automatic",
+			SWIFT_VERSION: "5.0",
+			COMBINE_HIDPI_IMAGES: "YES",
+			CLANG_ENABLE_MODULES: "YES",
+			SWIFT_OPTIMIZATION_LEVEL: "\"-Onone\""
+		};
+		const debugBuildSettings = {
+			...sharedBuildSettings,
+			DEBUG_INFORMATION_FORMAT: "\"dwarf\"",
+			GCC_OPTIMIZATION_LEVEL: "\"0\"",
+			SWIFT_ACTIVE_COMPILATION_CONDITIONS: "\"$(inherited) DEBUG\"",
+			MTL_ENABLE_DEBUG_INFO: "INCLUDE_SOURCE"
+		};
+		const releaseBuildSettings = {
+			...sharedBuildSettings,
+			DEBUG_INFORMATION_FORMAT: "\"dwarf-with-dsym\"",
+			SWIFT_OPTIMIZATION_LEVEL: "\"-O\"",
+			COPY_PHASE_STRIP: "YES",
+			ENABLE_NS_ASSERTIONS: "NO"
+		};
+		const configList = project.addXCConfigurationList([{
+			name: "Debug",
+			isa: "XCBuildConfiguration",
+			buildSettings: debugBuildSettings
+		}, {
+			name: "Release",
+			isa: "XCBuildConfiguration",
+			buildSettings: releaseBuildSettings
+		}], "Release", `Build configuration list for PBXNativeTarget "${serviceName}"`);
+		const productFileRefUuid = project.generateUuid();
+		objects.PBXFileReference[productFileRefUuid] = {
+			isa: "PBXFileReference",
+			explicitFileType: XPC_PRODUCT_FILE_TYPE,
+			includeInIndex: 0,
+			path: `${serviceName}.xpc`,
+			sourceTree: "BUILT_PRODUCTS_DIR",
+			name: `${serviceName}.xpc`
+		};
+		objects.PBXFileReference[`${productFileRefUuid}_comment`] = `${serviceName}.xpc`;
+		const productsGroupKey = project.findPBXGroupKey({ name: "Products" });
+		if (productsGroupKey) project.addToPbxGroup({
+			fileRef: productFileRefUuid,
+			basename: `${serviceName}.xpc`
+		}, productsGroupKey);
+		const xpcSourcesDir = findXPCSourcesDir(config.modRequest.projectRoot);
+		const swiftFiles = node_fs.default.readdirSync(xpcSourcesDir).filter((f) => node_fs.default.statSync(node_path.default.join(xpcSourcesDir, f)).isFile()).filter((f) => f.endsWith(".swift"));
+		const sourceFileRefs = [];
+		for (const fileName of swiftFiles) {
+			const fileRefUuid = project.generateUuid();
+			objects.PBXFileReference[fileRefUuid] = {
+				isa: "PBXFileReference",
+				lastKnownFileType: "sourcecode.swift",
+				path: fileName,
+				sourceTree: "\"<group>\"",
+				name: fileName
+			};
+			objects.PBXFileReference[`${fileRefUuid}_comment`] = fileName;
+			sourceFileRefs.push({
+				uuid: fileRefUuid,
+				name: fileName
+			});
+		}
+		const infoPlistRefUuid = project.generateUuid();
+		objects.PBXFileReference[infoPlistRefUuid] = {
+			isa: "PBXFileReference",
+			lastKnownFileType: "text.plist.xml",
+			path: "Info.plist",
+			sourceTree: "\"<group>\"",
+			name: "Info.plist"
+		};
+		objects.PBXFileReference[`${infoPlistRefUuid}_comment`] = "Info.plist";
+		const groupUuid = project.generateUuid();
+		const groupChildren = [...sourceFileRefs.map((ref) => ({
+			value: ref.uuid,
+			comment: ref.name
+		})), {
+			value: infoPlistRefUuid,
+			comment: "Info.plist"
+		}];
+		objects.PBXGroup[groupUuid] = {
+			isa: "PBXGroup",
+			children: groupChildren,
+			name: serviceName,
+			path: serviceName,
+			sourceTree: "\"<group>\""
+		};
+		objects.PBXGroup[`${groupUuid}_comment`] = serviceName;
+		const firstProject = project.getFirstProject();
+		const mainGroupKey = firstProject.firstProject.mainGroup;
+		const mainGroup = project.getPBXGroupByKey(mainGroupKey);
+		if (mainGroup) mainGroup.children.push({
+			value: groupUuid,
+			comment: serviceName
+		});
+		const buildFileUuids = [];
+		for (const ref of sourceFileRefs) {
+			const buildFileUuid = project.generateUuid();
+			objects.PBXBuildFile[buildFileUuid] = {
+				isa: "PBXBuildFile",
+				fileRef: ref.uuid,
+				fileRef_comment: ref.name
+			};
+			objects.PBXBuildFile[`${buildFileUuid}_comment`] = `${ref.name} in Sources`;
+			buildFileUuids.push({
+				uuid: buildFileUuid,
+				name: ref.name
+			});
+		}
+		const sourcesBuildPhaseUuid = project.generateUuid();
+		objects.PBXSourcesBuildPhase = objects.PBXSourcesBuildPhase || {};
+		objects.PBXSourcesBuildPhase[sourcesBuildPhaseUuid] = {
+			isa: "PBXSourcesBuildPhase",
+			buildActionMask: 2147483647,
+			files: buildFileUuids.map((bf) => ({
+				value: bf.uuid,
+				comment: `${bf.name} in Sources`
+			})),
+			runOnlyForDeploymentPostprocessing: 0
+		};
+		objects.PBXSourcesBuildPhase[`${sourcesBuildPhaseUuid}_comment`] = "Sources";
+		const spmBuildFileUuid = project.generateUuid();
+		objects.PBXBuildFile[spmBuildFileUuid] = {
+			isa: "PBXBuildFile",
+			productRef: spmProductDepUuid,
+			productRef_comment: SPM_PRODUCT_NAME
+		};
+		objects.PBXBuildFile[`${spmBuildFileUuid}_comment`] = `${SPM_PRODUCT_NAME} in Frameworks`;
+		const frameworkFiles = [{
+			value: spmBuildFileUuid,
+			comment: `${SPM_PRODUCT_NAME} in Frameworks`
+		}];
+		for (const remoteDep of remoteProductDeps) {
+			const remoteBuildFileUuid = project.generateUuid();
+			objects.PBXBuildFile[remoteBuildFileUuid] = {
+				isa: "PBXBuildFile",
+				productRef: remoteDep.productDepUuid,
+				productRef_comment: remoteDep.productName
+			};
+			objects.PBXBuildFile[`${remoteBuildFileUuid}_comment`] = `${remoteDep.productName} in Frameworks`;
+			frameworkFiles.push({
+				value: remoteBuildFileUuid,
+				comment: `${remoteDep.productName} in Frameworks`
+			});
+		}
+		const frameworksBuildPhaseUuid = project.generateUuid();
+		objects.PBXFrameworksBuildPhase = objects.PBXFrameworksBuildPhase || {};
+		objects.PBXFrameworksBuildPhase[frameworksBuildPhaseUuid] = {
+			isa: "PBXFrameworksBuildPhase",
+			buildActionMask: 2147483647,
+			files: frameworkFiles,
+			runOnlyForDeploymentPostprocessing: 0
+		};
+		objects.PBXFrameworksBuildPhase[`${frameworksBuildPhaseUuid}_comment`] = "Frameworks";
+		const targetUuid = project.generateUuid();
+		const nativeTarget = {
+			isa: "PBXNativeTarget",
+			name: serviceName,
+			productName: serviceName,
+			productReference: productFileRefUuid,
+			productType: `"${XPC_PRODUCT_TYPE}"`,
+			buildConfigurationList: configList.uuid,
+			buildPhases: [{
+				value: sourcesBuildPhaseUuid,
+				comment: "Sources"
+			}, {
+				value: frameworksBuildPhaseUuid,
+				comment: "Frameworks"
+			}],
+			buildRules: [],
+			dependencies: []
+		};
+		nativeTarget.packageProductDependencies = [{
+			value: spmProductDepUuid,
+			comment: SPM_PRODUCT_NAME
+		}, ...remoteProductDeps.map((dep) => ({
+			value: dep.productDepUuid,
+			comment: dep.productName
+		}))];
+		objects.PBXNativeTarget[targetUuid] = nativeTarget;
+		objects.PBXNativeTarget[`${targetUuid}_comment`] = serviceName;
+		for (const key of Object.keys(projectSection)) if (!key.endsWith("_comment")) projectSection[key].targets.push({
+			value: targetUuid,
+			comment: serviceName
+		});
+		const appTarget = project.getFirstTarget();
+		const appTargetUuid = appTarget.uuid;
+		const xpcCopyBuildFileUuid = project.generateUuid();
+		objects.PBXBuildFile[xpcCopyBuildFileUuid] = {
+			isa: "PBXBuildFile",
+			fileRef: productFileRefUuid,
+			fileRef_comment: `${serviceName}.xpc`,
+			settings: { ATTRIBUTES: ["RemoveHeadersOnCopy"] }
+		};
+		objects.PBXBuildFile[`${xpcCopyBuildFileUuid}_comment`] = `${serviceName}.xpc in Embed XPC Services`;
+		const copyPhaseUuid = project.generateUuid();
+		const copyPhaseSection = objects["PBXCopyFilesBuildPhase"] || (objects["PBXCopyFilesBuildPhase"] = {});
+		copyPhaseSection[copyPhaseUuid] = {
+			isa: "PBXCopyFilesBuildPhase",
+			buildActionMask: 2147483647,
+			dstPath: "\"$(CONTENTS_FOLDER_PATH)/XPCServices\"",
+			dstSubfolderSpec: 16,
+			files: [{
+				value: xpcCopyBuildFileUuid,
+				comment: `${serviceName}.xpc in Embed XPC Services`
+			}],
+			name: "\"Embed XPC Services\"",
+			runOnlyForDeploymentPostprocessing: 0
+		};
+		copyPhaseSection[`${copyPhaseUuid}_comment`] = "Embed XPC Services";
+		const appNativeTarget = objects.PBXNativeTarget[appTargetUuid] || appTarget.firstTarget;
+		if (appNativeTarget && "buildPhases" in appNativeTarget) appNativeTarget.buildPhases.push({
+			value: copyPhaseUuid,
+			comment: "Embed XPC Services"
+		});
+		const proxyUuid = project.generateUuid();
+		const proxySection = objects["PBXContainerItemProxy"] || (objects["PBXContainerItemProxy"] = {});
+		proxySection[proxyUuid] = {
+			isa: "PBXContainerItemProxy",
+			containerPortal: project.hash.project.rootObject,
+			containerPortal_comment: "Project object",
+			proxyType: 1,
+			remoteGlobalIDString: targetUuid,
+			remoteInfo: serviceName
+		};
+		proxySection[`${proxyUuid}_comment`] = "PBXContainerItemProxy";
+		const depUuid = project.generateUuid();
+		const depSection = objects["PBXTargetDependency"] || (objects["PBXTargetDependency"] = {});
+		depSection[depUuid] = {
+			isa: "PBXTargetDependency",
+			target: targetUuid,
+			target_comment: serviceName,
+			targetProxy: proxyUuid,
+			targetProxy_comment: "PBXContainerItemProxy"
+		};
+		depSection[`${depUuid}_comment`] = "PBXTargetDependency";
+		if (appNativeTarget && "dependencies" in appNativeTarget) appNativeTarget.dependencies.push({
+			value: depUuid,
+			comment: "PBXTargetDependency"
+		});
+		const projectObj = firstProject.firstProject;
+		if (!projectObj.attributes.TargetAttributes) projectObj.attributes.TargetAttributes = {};
+		projectObj.attributes.TargetAttributes[targetUuid] = {
+			CreatedOnToolsVersion: "15.0",
+			DevelopmentTeam: teamId
+		};
+		console.log(`[xpc] Added XPC target "${serviceName}" (${bundleId}) with SPM dependency`);
+		return config;
+	});
+	return config;
+};
+const pkg = {
+	name: "@macify/xpc",
+	version: "0.0.1"
+};
+var src_default = (0, _expo_config_plugins.createRunOncePlugin)(withXPCService, pkg.name, pkg.version);
+
+//#endregion
+module.exports = src_default;

package/plugin/build/index.d.cts

@@ -0,0 +1,17 @@
+import { ConfigPlugin } from "@expo/config-plugins";
+
+//#region plugin/src/index.d.ts
+type RemoteSPMDependency = {
+  url: string;
+  version?: string;
+  exactVersion?: string;
+  branch?: string;
+  products: string[];
+};
+type PluginProps = {
+  serviceName?: string;
+  macosDeploymentTarget?: string;
+  dependencies?: RemoteSPMDependency[];
+};
+declare const _default: ConfigPlugin<PluginProps>;
+export = _default;

package/swift/Package.swift

@@ -0,0 +1,19 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "MacifyXPCService",
+    platforms: [.macOS(.v13)],
+    products: [
+        .library(
+            name: "MacifyXPCService",
+            targets: ["MacifyXPCService"]
+        ),
+    ],
+    targets: [
+        .target(
+            name: "MacifyXPCService",
+            path: "Sources/MacifyXPCService"
+        ),
+    ]
+)

package/swift/Sources/MacifyXPCService/MacifyServiceImpl.swift

@@ -0,0 +1,51 @@
+import Foundation
+
+/// The XPC service implementation that receives generic JSON RPC calls
+/// and dispatches them to the user's `XPCMessageHandler`.
+public class MacifyServiceImpl: NSObject, MacifyXPCProtocol {
+    private let handler: XPCMessageHandler
+    private let emitter: XPCEventEmitter
+
+    public init(handler: XPCMessageHandler, connection: NSXPCConnection) {
+        self.handler = handler
+        self.emitter = XPCEventEmitter(connection: connection)
+        super.init()
+    }
+
+    public func call(
+        type: String,
+        payload: Data,
+        withReply reply: @escaping (Data?, NSError?) -> Void
+    ) {
+        Task {
+            do {
+                // Decode incoming JSON payload
+                let decoded: [String: Any]
+                if payload.isEmpty {
+                    decoded = [:]
+                } else {
+                    guard let json = try JSONSerialization.jsonObject(
+                        with: payload, options: []
+                    ) as? [String: Any] else {
+                        throw MacifyXPCError.invalidPayload
+                    }
+                    decoded = json
+                }
+
+                // Dispatch to user's handler
+                let result = try await handler.handle(
+                    type: type, payload: decoded, emitter: emitter
+                )
+
+                // Encode response
+                let responseData = try JSONSerialization.data(
+                    withJSONObject: result, options: []
+                )
+                reply(responseData, nil)
+            } catch {
+                let nsError = error as NSError
+                reply(nil, nsError)
+            }
+        }
+    }
+}

package/swift/Sources/MacifyXPCService/MacifyXPCError.swift

@@ -0,0 +1,22 @@
+import Foundation
+
+/// Errors that can occur in the XPC service.
+public enum MacifyXPCError: LocalizedError {
+    case unknownMethod(String)
+    case invalidPayload
+    case serializationFailed(String)
+    case connectionLost
+
+    public var errorDescription: String? {
+        switch self {
+        case .unknownMethod(let method):
+            return "Unknown XPC method: \(method)"
+        case .invalidPayload:
+            return "Invalid JSON payload"
+        case .serializationFailed(let detail):
+            return "Serialization failed: \(detail)"
+        case .connectionLost:
+            return "XPC connection was lost"
+        }
+    }
+}

package/swift/Sources/MacifyXPCService/MacifyXPCProtocol.swift

@@ -0,0 +1,21 @@
+import Foundation
+
+/// Wire protocol for RPC calls from the app to the XPC service.
+/// Both the app-side pod and the XPC service SPM library compile their own
+/// copy of this protocol definition.
+@objc public protocol MacifyXPCProtocol {
+    /// Generic RPC: the app sends a message type and JSON-encoded payload,
+    /// the XPC service processes it and replies with JSON-encoded data or an error.
+    func call(
+        type: String,
+        payload: Data,
+        withReply reply: @escaping (Data?, NSError?) -> Void
+    )
+}
+
+/// Reverse channel: the XPC service pushes events back to the app.
+/// The app sets its exported object conforming to this protocol on the
+/// NSXPCConnection so the XPC service can call back into it.
+@objc public protocol MacifyXPCEventReceiver {
+    func handleEvent(type: String, payload: Data)
+}

package/swift/Sources/MacifyXPCService/XPCEventEmitter.swift

@@ -0,0 +1,29 @@
+import Foundation
+
+/// Allows the XPC service to push events back to the app.
+/// The emitter holds a weak reference to the connection's event receiver proxy.
+public class XPCEventEmitter {
+    private weak var connection: NSXPCConnection?
+
+    init(connection: NSXPCConnection) {
+        self.connection = connection
+    }
+
+    /// Send an event to the app.
+    /// - Parameters:
+    ///   - type: Event type string (e.g. "progress", "status")
+    ///   - payload: Dictionary that will be JSON-encoded
+    public func emit(_ type: String, payload: [String: Any] = [:]) {
+        guard let connection = connection else { return }
+
+        do {
+            let data = try JSONSerialization.data(
+                withJSONObject: payload, options: []
+            )
+            let proxy = connection.remoteObjectProxy as? MacifyXPCEventReceiver
+            proxy?.handleEvent(type: type, payload: data)
+        } catch {
+            print("[MacifyXPCService] Failed to serialize event payload: \(error)")
+        }
+    }
+}

package/swift/Sources/MacifyXPCService/XPCMessageHandler.swift

@@ -0,0 +1,18 @@
+import Foundation
+
+/// Protocol that users implement to handle XPC messages.
+/// The user's `main.swift` creates a struct conforming to this and passes
+/// it to `XPCServiceHost.start(handler:)`.
+public protocol XPCMessageHandler {
+    /// Handle an incoming RPC call.
+    /// - Parameters:
+    ///   - type: The message type string (e.g. "ping", "processImage")
+    ///   - payload: Decoded JSON payload as a dictionary
+    ///   - emitter: Used to push events back to the app
+    /// - Returns: A dictionary that will be JSON-encoded and sent back as the reply
+    func handle(
+        type: String,
+        payload: [String: Any],
+        emitter: XPCEventEmitter
+    ) async throws -> [String: Any]
+}

package/swift/Sources/MacifyXPCService/XPCServiceHost.swift

@@ -0,0 +1,75 @@
+import Foundation
+
+/// Entry point for XPC services built with MacifyXPCService.
+///
+/// Usage in `main.swift`:
+/// ```swift
+/// import MacifyXPCService
+///
+/// struct MyHandler: XPCMessageHandler {
+///     func handle(type: String, payload: [String: Any], emitter: XPCEventEmitter) async throws -> [String: Any] {
+///         switch type {
+///         case "ping":
+///             return ["message": "pong"]
+///         default:
+///             throw MacifyXPCError.unknownMethod(type)
+///         }
+///     }
+/// }
+///
+/// XPCServiceHost.start(handler: MyHandler())
+/// ```
+public enum XPCServiceHost {
+    /// Start the XPC service listener with the given message handler.
+    /// This function never returns — it runs the main run loop.
+    public static func start(handler: XPCMessageHandler) {
+        let delegate = ServiceDelegate(handler: handler)
+        let listener = NSXPCListener.service()
+        listener.delegate = delegate
+
+        // Keep a strong reference so the delegate isn't deallocated
+        _delegate = delegate
+
+        listener.resume()
+    }
+
+    // Strong reference to prevent deallocation
+    private static var _delegate: ServiceDelegate?
+}
+
+/// Internal delegate that vends `MacifyServiceImpl` instances to incoming connections.
+class ServiceDelegate: NSObject, NSXPCListenerDelegate {
+    let handler: XPCMessageHandler
+
+    init(handler: XPCMessageHandler) {
+        self.handler = handler
+        super.init()
+    }
+
+    func listener(
+        _ listener: NSXPCListener,
+        shouldAcceptNewConnection connection: NSXPCConnection
+    ) -> Bool {
+        // Set the interface the service exports (app calls us)
+        connection.exportedInterface = NSXPCInterface(
+            with: MacifyXPCProtocol.self
+        )
+
+        // Set the interface the app exports (we call back for events)
+        connection.remoteObjectInterface = NSXPCInterface(
+            with: MacifyXPCEventReceiver.self
+        )
+
+        // Vend the service implementation
+        connection.exportedObject = MacifyServiceImpl(
+            handler: handler, connection: connection
+        )
+
+        connection.invalidationHandler = {
+            // Connection cleaned up
+        }
+
+        connection.resume()
+        return true
+    }
+}