bleam 0.0.7 → 0.0.9

package/templates/native/ios/Bleam/AppDelegate.swift

@@ -0,0 +1,373 @@
+internal import Expo
+import React
+import ReactAppDependencyProvider
+import UIKit
+import CryptoKit
+import Darwin
+
+func launchArgument(_ name: String) -> String? {
+  let arguments = ProcessInfo.processInfo.arguments
+  guard let flagIndex = arguments.firstIndex(of: name) else {
+    return nil
+  }
+
+  let valueIndex = arguments.index(after: flagIndex)
+  guard arguments.indices.contains(valueIndex) else {
+    return nil
+  }
+
+  return arguments[valueIndex]
+}
+
+@main
+class AppDelegate: ExpoAppDelegate {
+  public override func application(
+    _ application: UIApplication,
+    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil
+  ) -> Bool {
+    let launched = super.application(application, didFinishLaunchingWithOptions: launchOptions)
+    if launched {
+      PlatformHelperInstaller.refreshIfInstalledApp()
+    }
+    return launched
+  }
+
+  public func application(
+    _ application: UIApplication,
+    configurationForConnecting connectingSceneSession: UISceneSession,
+    options: UIScene.ConnectionOptions
+  ) -> UISceneConfiguration {
+    let configuration = UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
+    configuration.delegateClass = SceneDelegate.self
+    return configuration
+  }
+
+  // Linking API
+  public override func application(
+    _ app: UIApplication,
+    open url: URL,
+    options: [UIApplication.OpenURLOptionsKey: Any] = [:]
+  ) -> Bool {
+    return super.application(app, open: url, options: options) || RCTLinkingManager.application(app, open: url, options: options)
+  }
+
+  // Universal Links
+  public override func application(
+    _ application: UIApplication,
+    continue userActivity: NSUserActivity,
+    restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
+  ) -> Bool {
+    let result = RCTLinkingManager.application(application, continue: userActivity, restorationHandler: restorationHandler)
+    return super.application(application, continue: userActivity, restorationHandler: restorationHandler) || result
+  }
+}
+
+private enum PlatformHelperInstaller {
+  static func refreshIfInstalledApp() {
+#if targetEnvironment(macCatalyst)
+    let homeDirectory = URL(fileURLWithPath: NSHomeDirectory(), isDirectory: true)
+    let homeApplications = homeDirectory
+      .appendingPathComponent("Applications", isDirectory: true)
+      .standardizedFileURL.path + "/"
+    guard Bundle.main.bundleURL.standardizedFileURL.path.hasPrefix(homeApplications) else {
+      return
+    }
+    guard let bundleIdentifier = Bundle.main.bundleIdentifier else { return }
+
+    let serviceName = "PlatformHelper"
+    let bundledService = Bundle.main.bundleURL
+      .appendingPathComponent("Contents/XPCServices/\(serviceName).xpc", isDirectory: true)
+    guard FileManager.default.fileExists(atPath: bundledService.path) else {
+      NSLog("Bleam helper unavailable: bundled executable is missing")
+      return
+    }
+
+    let label = "\(bundleIdentifier).PlatformHelper"
+    let domain = "gui/\(getuid())"
+    _ = runLaunchctl(["bootout", "\(domain)/\(label)"])
+
+    let helperRoot = homeDirectory
+      .appendingPathComponent("Library/Application Support/Bleam/Helpers", isDirectory: true)
+      .appendingPathComponent(bundleIdentifier, isDirectory: true)
+    let installedService = helperRoot.appendingPathComponent("\(serviceName).xpc", isDirectory: true)
+    let executable = installedService
+      .appendingPathComponent("Contents/MacOS/\(serviceName)")
+    let launchAgents = homeDirectory
+      .appendingPathComponent("Library/LaunchAgents", isDirectory: true)
+    let plistURL = launchAgents.appendingPathComponent("\(label).plist")
+    let propertyList: [String: Any] = [
+      "Label": label,
+      "ProgramArguments": [executable.path],
+      "RunAtLoad": true,
+      "KeepAlive": true,
+      "ProcessType": "Background",
+      "MachServices": ["\(bundleIdentifier).PlatformHelper": true],
+      "EnvironmentVariables": ["XPC_SERVICE_NAME": "\(bundleIdentifier).PlatformHelper"],
+    ]
+
+    do {
+      try FileManager.default.createDirectory(
+        at: helperRoot,
+        withIntermediateDirectories: true
+      )
+      try? FileManager.default.removeItem(at: installedService)
+      try FileManager.default.copyItem(at: bundledService, to: installedService)
+      try FileManager.default.createDirectory(
+        at: launchAgents,
+        withIntermediateDirectories: true
+      )
+      let data = try PropertyListSerialization.data(
+        fromPropertyList: propertyList,
+        format: .xml,
+        options: 0
+      )
+      try data.write(to: plistURL, options: .atomic)
+    } catch {
+      NSLog("Bleam helper install failed: %@", error.localizedDescription)
+      return
+    }
+
+    if runLaunchctl(["bootstrap", domain, plistURL.path]) != 0 {
+      NSLog("Bleam helper registration failed")
+    }
+#endif
+  }
+
+  private static func runLaunchctl(_ arguments: [String]) -> Int32 {
+    let values = ["launchctl"] + arguments
+    var argv = values.map { strdup($0) }
+    argv.append(nil)
+    defer { argv.compactMap { $0 }.forEach { free($0) } }
+
+    var pid: pid_t = 0
+    let result = posix_spawn(&pid, "/bin/launchctl", nil, nil, &argv, environ)
+    guard result == 0 else { return Int32(result) }
+    var status: Int32 = 0
+    guard waitpid(pid, &status, 0) == pid else { return -1 }
+    return status
+  }
+}
+
+class ReactNativeDelegate: ExpoReactNativeFactoryDelegate {
+  private let bundleOverrideURL: URL?
+
+  init(bundleURL: URL? = nil) {
+    bundleOverrideURL = bundleURL
+    super.init()
+  }
+
+  // Extension point for config-plugins
+
+  override func sourceURL(for bridge: RCTBridge) -> URL? {
+    // needed to return the correct URL for expo-dev-client.
+    bridge.bundleURL ?? bundleURL()
+  }
+
+  override func customize(_ rootView: UIView) {
+    super.customize(rootView)
+    applyRootAppearance(to: rootView)
+  }
+
+  override func bundleURL() -> URL? {
+    if let bundleOverrideURL {
+      return bundleOverrideURL
+    }
+
+    if let bundleURL = launchArgument("--bleam-bundle-url") {
+      return URL(string: bundleURL)
+    }
+
+#if DEBUG
+    return RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: ".expo/.virtual-metro-entry")
+#else
+    return OTAUpdateManager.shared.launchBundleURL()
+#endif
+  }
+}
+
+private struct OTAArtifact: Decodable {
+  let url: URL
+  let sizeBytes: Int
+  let sha256: String
+}
+
+private struct OTARelease: Decodable {
+  let schemaVersion: Int
+  let kind: String
+  let releaseId: String
+  let bundleIdentifier: String
+  let teamIdentifier: String
+  let runtimeVersion: String
+  let artifact: OTAArtifact
+}
+
+final class OTAUpdateManager {
+  static let shared = OTAUpdateManager()
+
+  private let fileManager = FileManager.default
+  private let defaults = UserDefaults.standard
+  private let activeKey = "BleamOTAActiveRelease"
+  private let attemptedKey = "BleamOTAAttemptedRelease"
+  private let rejectedKey = "BleamOTARejectedRelease"
+  private var launchingRelease: String?
+
+  private var cacheRoot: URL {
+    let caches = fileManager.urls(for: .cachesDirectory, in: .userDomainMask)[0]
+    let bundleIdentifier = Bundle.main.bundleIdentifier ?? "app"
+    return caches.appendingPathComponent("Bleam/OTA/\(bundleIdentifier)", isDirectory: true)
+  }
+
+  private init() {
+    for name in ["RCTJavaScriptDidLoadNotification", "RCTContentDidAppearNotification"] {
+      NotificationCenter.default.addObserver(
+        forName: NSNotification.Name(rawValue: name),
+        object: nil,
+        queue: .main
+      ) { [weak self] _ in
+        self?.markLaunchSuccessful()
+      }
+    }
+  }
+
+  func launchBundleURL() -> URL? {
+    guard let releaseId = defaults.string(forKey: activeKey) else {
+      return embeddedBundleURL()
+    }
+
+    if defaults.string(forKey: attemptedKey) == releaseId {
+      defaults.set(releaseId, forKey: rejectedKey)
+      defaults.removeObject(forKey: activeKey)
+      defaults.removeObject(forKey: attemptedKey)
+      return embeddedBundleURL()
+    }
+
+    let bundle = cacheRoot
+      .appendingPathComponent(releaseId, isDirectory: true)
+      .appendingPathComponent("bundle/bundle.js")
+    guard fileManager.fileExists(atPath: bundle.path) else {
+      defaults.removeObject(forKey: activeKey)
+      return embeddedBundleURL()
+    }
+
+    launchingRelease = releaseId
+    defaults.set(releaseId, forKey: attemptedKey)
+    return bundle
+  }
+
+  func checkForUpdate() {
+    guard
+      let baseUrlString = Bundle.main.object(forInfoDictionaryKey: "BleamUpdateServiceURL") as? String,
+      let baseUrl = URL(string: baseUrlString),
+      let bundleIdentifier = Bundle.main.bundleIdentifier,
+      let runtimeVersion = Bundle.main.object(forInfoDictionaryKey: "BleamRuntimeVersion") as? String
+    else {
+      NSLog("Bleam OTA disabled: missing update URL, bundle identifier, or runtime version")
+      return
+    }
+
+    let path = "/v1/apps/\(bundleIdentifier)/ota/\(runtimeVersion)"
+    guard let url = URL(string: path, relativeTo: baseUrl)?.absoluteURL else {
+      NSLog("Bleam OTA disabled: invalid resolver URL")
+      return
+    }
+
+    NSLog("Bleam OTA checking %@", url.absoluteString)
+    URLSession.shared.dataTask(with: url) { [weak self] data, response, error in
+      if let error {
+        NSLog("Bleam OTA resolver failed: %@", error.localizedDescription)
+      }
+      guard
+        let self,
+        let response = response as? HTTPURLResponse,
+        response.statusCode == 200,
+        let data,
+        let release = try? JSONDecoder().decode(OTARelease.self, from: data)
+      else {
+        let status = (response as? HTTPURLResponse)?.statusCode ?? 0
+        NSLog("Bleam OTA resolver returned an unusable response: %d", status)
+        return
+      }
+      self.download(release)
+    }.resume()
+  }
+
+  private func download(_ release: OTARelease) {
+    guard
+      release.schemaVersion == 1,
+      release.kind == "ota",
+      release.bundleIdentifier == Bundle.main.bundleIdentifier,
+      release.runtimeVersion == Bundle.main.object(forInfoDictionaryKey: "BleamRuntimeVersion") as? String,
+      release.teamIdentifier == Bundle.main.object(forInfoDictionaryKey: "BleamTeamIdentifier") as? String,
+      release.releaseId != defaults.string(forKey: activeKey),
+      release.releaseId != defaults.string(forKey: rejectedKey)
+    else {
+      NSLog("Bleam OTA rejected release %@", release.releaseId)
+      return
+    }
+
+    NSLog("Bleam OTA downloading %@", release.releaseId)
+    URLSession.shared.downloadTask(with: release.artifact.url) { [weak self] temporaryUrl, _, error in
+      if let error {
+        NSLog("Bleam OTA download failed: %@", error.localizedDescription)
+      }
+      guard let self, let temporaryUrl else { return }
+      guard
+        let attributes = try? self.fileManager.attributesOfItem(atPath: temporaryUrl.path),
+        attributes[.size] as? Int == release.artifact.sizeBytes,
+        let data = try? Data(contentsOf: temporaryUrl),
+        SHA256.hash(data: data).map({ String(format: "%02x", $0) }).joined() == release.artifact.sha256
+      else {
+        NSLog("Bleam OTA artifact verification failed for %@", release.releaseId)
+        return
+      }
+
+      let destination = self.cacheRoot.appendingPathComponent(release.releaseId, isDirectory: true)
+      try? self.fileManager.removeItem(at: destination)
+      do {
+        try self.fileManager.createDirectory(at: destination, withIntermediateDirectories: true)
+        try self.extract(temporaryUrl, to: destination)
+        guard self.fileManager.fileExists(
+          atPath: destination.appendingPathComponent("bundle/bundle.js").path
+        ) else {
+          try? self.fileManager.removeItem(at: destination)
+          return
+        }
+        self.defaults.removeObject(forKey: self.attemptedKey)
+        self.defaults.set(release.releaseId, forKey: self.activeKey)
+        NSLog("Bleam OTA staged %@ for next launch", release.releaseId)
+      } catch {
+        NSLog("Bleam OTA extraction failed: %@", error.localizedDescription)
+        try? self.fileManager.removeItem(at: destination)
+      }
+    }.resume()
+  }
+
+  private func extract(_ archive: URL, to destination: URL) throws {
+    let arguments = ["ditto", "-x", "-k", archive.path, destination.path]
+    var argv = arguments.map { strdup($0) }
+    argv.append(nil)
+    defer { argv.compactMap { $0 }.forEach { free($0) } }
+
+    var pid: pid_t = 0
+    let spawnResult = posix_spawn(&pid, "/usr/bin/ditto", nil, nil, &argv, environ)
+    guard spawnResult == 0 else {
+      throw NSError(domain: NSPOSIXErrorDomain, code: Int(spawnResult))
+    }
+    var status: Int32 = 0
+    guard waitpid(pid, &status, 0) == pid, status == 0 else {
+      throw NSError(domain: NSPOSIXErrorDomain, code: Int(status))
+    }
+  }
+
+  private func markLaunchSuccessful() {
+    guard let releaseId = launchingRelease else { return }
+    defaults.removeObject(forKey: attemptedKey)
+    launchingRelease = nil
+    let releaseRoot = cacheRoot.appendingPathComponent(releaseId, isDirectory: true)
+    try? fileManager.createDirectory(at: releaseRoot, withIntermediateDirectories: true)
+  }
+
+  private func embeddedBundleURL() -> URL? {
+    Bundle.main.url(forResource: "main", withExtension: "jsbundle")
+  }
+}

package/templates/native/ios/Bleam/Appearance.swift

@@ -0,0 +1,62 @@
+import UIKit
+
+struct Appearance {
+  let windowBackgroundColor: UIColor?
+  let userInterfaceStyle: UIUserInterfaceStyle
+
+  static let `default` = Appearance(
+    windowBackgroundColor: nil,
+    userInterfaceStyle: .unspecified
+  )
+}
+
+func parseColor(from hex: String?) -> UIColor? {
+  guard let hex else {
+    return nil
+  }
+
+  let value = hex.trimmingCharacters(in: .whitespacesAndNewlines).replacingOccurrences(of: "#", with: "")
+  guard value.count == 6, let number = Int(value, radix: 16) else {
+    return nil
+  }
+
+  return UIColor(
+    red: CGFloat((number >> 16) & 0xff) / 255,
+    green: CGFloat((number >> 8) & 0xff) / 255,
+    blue: CGFloat(number & 0xff) / 255,
+    alpha: 1
+  )
+}
+
+func parseAppearance(from value: Any?) -> Appearance {
+  guard let object = value as? [String: Any] else {
+    return .default
+  }
+
+  let window = object["window"] as? [String: Any]
+  let style = object["userInterfaceStyle"] as? String
+
+  return Appearance(
+    windowBackgroundColor: parseColor(from: window?["backgroundColor"] as? String),
+    userInterfaceStyle: style == "light" ? .light : style == "dark" ? .dark : .unspecified
+  )
+}
+
+func projectAppearance() -> Appearance {
+  guard let configPath = launchArgument("--bleam-project-config") else {
+    return .default
+  }
+
+  do {
+    let data = try Data(contentsOf: URL(fileURLWithPath: configPath))
+    let value = try JSONSerialization.jsonObject(with: data) as? [String: Any]
+    return parseAppearance(from: value?["appearance"])
+  } catch {
+    return .default
+  }
+}
+
+func applyRootAppearance(to rootView: UIView) {
+  rootView.backgroundColor = .clear
+  rootView.isOpaque = false
+}

package/templates/native/ios/Bleam/Bridging-Header.h

@@ -0,0 +1,3 @@
+//
+// Use this file to import your target's public headers that you would like to expose to Swift.
+//

package/templates/native/ios/Bleam/Images.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,13 @@
+{
+  "images" : [
+    {
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : {
+    "version" : 1,
+    "author" : "expo"
+  }
+}

package/templates/native/ios/Bleam/Images.xcassets/Contents.json

@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "version" : 1,
+    "author" : "expo"
+  }
+}

package/templates/native/ios/Bleam/Info.plist

@@ -0,0 +1,76 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CADisableMinimumFrameDurationOnPhone</key>
+	<true/>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundleDisplayName</key>
+	<string>Bleam</string>
+	<key>CFBundlePackageType</key>
+	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+	<key>AppGroupIdentifier</key>
+	<string>group.dev.bleam.app</string>
+	<key>LSMinimumSystemVersion</key>
+	<string>12.0</string>
+	<key>LSRequiresIPhoneOS</key>
+	<true/>
+	<key>NSAppTransportSecurity</key>
+	<dict>
+		<key>NSAllowsArbitraryLoads</key>
+		<false/>
+		<key>NSAllowsLocalNetworking</key>
+		<true/>
+	</dict>
+	<key>RCTNewArchEnabled</key>
+	<true/>
+	<key>UILaunchStoryboardName</key>
+	<string>SplashScreen</string>
+	<key>UIRequiredDeviceCapabilities</key>
+	<array>
+		<string>arm64</string>
+	</array>
+	<key>UIStatusBarStyle</key>
+	<string>UIStatusBarStyleDefault</string>
+	<key>UIApplicationSceneManifest</key>
+	<dict>
+		<key>UIApplicationSupportsMultipleScenes</key>
+		<false/>
+		<key>UISceneConfigurations</key>
+		<dict>
+			<key>UIWindowSceneSessionRoleApplication</key>
+			<array>
+				<dict>
+					<key>UISceneConfigurationName</key>
+					<string>Default Configuration</string>
+					<key>UISceneDelegateClassName</key>
+					<string>$(PRODUCT_MODULE_NAME).SceneDelegate</string>
+				</dict>
+			</array>
+		</dict>
+	</dict>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+	<key>UIViewControllerBasedStatusBarAppearance</key>
+	<false/>
+</dict>
+</plist>

package/templates/native/ios/Bleam/PrivacyInfo.xcprivacy

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>NSPrivacyAccessedAPITypes</key>
+	<array>
+		<dict>
+			<key>NSPrivacyAccessedAPIType</key>
+			<string>NSPrivacyAccessedAPICategoryUserDefaults</string>
+			<key>NSPrivacyAccessedAPITypeReasons</key>
+			<array>
+				<string>CA92.1</string>
+			</array>
+		</dict>
+		<dict>
+			<key>NSPrivacyAccessedAPIType</key>
+			<string>NSPrivacyAccessedAPICategoryFileTimestamp</string>
+			<key>NSPrivacyAccessedAPITypeReasons</key>
+			<array>
+				<string>0A2A.1</string>
+				<string>3B52.1</string>
+				<string>C617.1</string>
+			</array>
+		</dict>
+		<dict>
+			<key>NSPrivacyAccessedAPIType</key>
+			<string>NSPrivacyAccessedAPICategoryDiskSpace</string>
+			<key>NSPrivacyAccessedAPITypeReasons</key>
+			<array>
+				<string>E174.1</string>
+				<string>85F4.1</string>
+			</array>
+		</dict>
+		<dict>
+			<key>NSPrivacyAccessedAPIType</key>
+			<string>NSPrivacyAccessedAPICategorySystemBootTime</string>
+			<key>NSPrivacyAccessedAPITypeReasons</key>
+			<array>
+				<string>35F9.1</string>
+			</array>
+		</dict>
+	</array>
+	<key>NSPrivacyCollectedDataTypes</key>
+	<array/>
+	<key>NSPrivacyTracking</key>
+	<false/>
+</dict>
+</plist>

package/templates/native/ios/Bleam/SceneDelegate.swift

@@ -0,0 +1,58 @@
+internal import Expo
+import React
+import ReactAppDependencyProvider
+import UIKit
+
+class SceneDelegate: UIResponder, UIWindowSceneDelegate {
+  var window: UIWindow?
+  var reactNativeDelegate: ReactNativeDelegate?
+  var reactNativeFactory: ExpoReactNativeFactory?
+
+  func scene(
+    _ scene: UIScene,
+    willConnectTo _: UISceneSession,
+    options _: UIScene.ConnectionOptions
+  ) {
+    guard let windowScene = scene as? UIWindowScene else {
+      return
+    }
+
+    let bundleURL = SceneDelegate.bundleURL()
+    let title = launchArgument("--bleam-title")
+    let appearance = projectAppearance()
+
+    let delegate = ReactNativeDelegate(bundleURL: bundleURL)
+    let factory = ExpoReactNativeFactory(delegate: delegate)
+    delegate.dependencyProvider = RCTAppDependencyProvider()
+
+    let window = UIWindow(windowScene: windowScene)
+    if let windowBackgroundColor = appearance.windowBackgroundColor {
+      window.backgroundColor = windowBackgroundColor
+    }
+    window.overrideUserInterfaceStyle = appearance.userInterfaceStyle
+    factory.startReactNative(
+      withModuleName: "main",
+      in: window,
+      initialProperties: [:],
+      launchOptions: nil
+    )
+    window.rootViewController?.overrideUserInterfaceStyle = appearance.userInterfaceStyle
+    if let rootView = window.rootViewController?.view {
+      applyRootAppearance(to: rootView)
+    }
+    window.rootViewController?.title = title ?? "Bleam"
+
+    self.window = window
+    reactNativeDelegate = delegate
+    reactNativeFactory = factory
+    OTAUpdateManager.shared.checkForUpdate()
+  }
+
+  private static func bundleURL() -> URL? {
+    guard let bundleURLString = launchArgument("--bleam-bundle-url") else {
+      return nil
+    }
+
+    return URL(string: bundleURLString)
+  }
+}