bleam 0.0.8 → 0.0.10

package/templates/native/modules/bleam-runtime/ios/GenerationContracts.swift

@@ -0,0 +1,135 @@
+import Foundation
+
+@objc protocol GenerationServiceProtocol {
+  func startGeneration(requestData: Data, reply: @escaping (Bool) -> Void)
+  func cancelGeneration(reply: @escaping (Bool) -> Void)
+  func memoryTelemetry(reply: @escaping (Data?) -> Void)
+  func shutdown(reply: @escaping (Bool) -> Void)
+}
+
+@objc protocol GenerationServiceClientProtocol {
+  func generationWorkerDidEmit(eventData: Data)
+}
+
+struct GenerationWorkerRequest: Codable, Sendable {
+  let jobID: UUID
+  let model: String
+  let prompt: String
+  let sourceImagePath: String?
+  let maskImagePath: String?
+  let maskMode: String?
+  let outpaintWidth: Int?
+  let outpaintHeight: Int?
+  let outpaintSourceX: Int?
+  let outpaintSourceY: Int?
+  let outpaintSourceWidth: Int?
+  let outpaintSourceHeight: Int?
+  let outpaintAutoCrop: Bool?
+  let resizeMode: String?
+  let maxInputLongSide: Int?
+  let referenceImagePaths: [String]
+  let referenceInfluences: [Double]?
+  let loraPaths: [String]
+  let loraScales: [Double]?
+  let loraIds: [String]?
+  let sigmaSchedule: [Double]?
+  let width: Int
+  let height: Int
+  let steps: Int
+  let guidance: Double
+  let strength: Double?
+  let seed: Int?
+  let inputIds: [Int]
+  let attentionMask: [Int]
+  let modelRoot: String
+  let textEncoderPath: String
+  let transformerPath: String
+  let vaePath: String
+  let stagingDirectoryPath: String
+}
+
+struct GenerationWorkerEvent: Codable, Sendable {
+  enum EventType: String, Codable, Sendable {
+    case ready
+    case progress
+    case completed
+    case canceled
+    case failed
+    case log
+  }
+
+  let type: EventType
+  let message: String?
+  let currentStep: Int?
+  let totalSteps: Int?
+  let path: String?
+  let width: Int?
+  let height: Int?
+  let model: String?
+  let level: String?
+  let category: String?
+  let jobID: String?
+  let stage: String?
+  let metadata: GenerationWorkerMetadata?
+
+  init(
+    type: EventType,
+    message: String? = nil,
+    currentStep: Int? = nil,
+    totalSteps: Int? = nil,
+    path: String? = nil,
+    width: Int? = nil,
+    height: Int? = nil,
+    model: String? = nil,
+    level: String? = nil,
+    category: String? = nil,
+    jobID: String? = nil,
+    stage: String? = nil,
+    metadata: GenerationWorkerMetadata? = nil
+  ) {
+    self.type = type
+    self.message = message
+    self.currentStep = currentStep
+    self.totalSteps = totalSteps
+    self.path = path
+    self.width = width
+    self.height = height
+    self.model = model
+    self.level = level
+    self.category = category
+    self.jobID = jobID
+    self.stage = stage
+    self.metadata = metadata
+  }
+}
+
+struct GenerationWorkerFailure: LocalizedError {
+  let message: String
+  let stage: String?
+
+  init(message: String, stage: String? = nil) {
+    self.message = message
+    self.stage = stage
+  }
+
+  var errorDescription: String? { message }
+}
+
+struct GenerationWorkerMetadata: Codable, Sendable {
+  let model: String
+  let width: Int
+  let height: Int
+  let steps: Int
+  let guidance: Double
+  let strength: Double?
+  let seed: Int?
+  let elapsedMs: Int
+  let appliedLoRAs: [GenerationWorkerLoRA]?
+  let sigmaSchedule: [Double]?
+}
+
+struct GenerationWorkerLoRA: Codable, Sendable {
+  let id: String?
+  let path: String
+  let scale: Double
+}

package/templates/native/modules/bleam-runtime/ios/PlatformModule.swift

@@ -0,0 +1,329 @@
+import AVFoundation
+import Contacts
+import CoreLocation
+import EventKit
+import ExpoModulesCore
+import Foundation
+import Photos
+
+@objc private protocol PlatformHelperProtocol {
+  func health(reply: @escaping (Data?) -> Void)
+  func downloadPlatformUpdate(requestData: Data, reply: @escaping (Data?) -> Void)
+  func applyPlatformUpdate(requestData: Data, reply: @escaping (Bool) -> Void)
+}
+
+public final class PlatformModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("Platform")
+
+    AsyncFunction("helperStatus") { (promise: Promise) in
+      guard Self.isSupportedInstallLocation else {
+        UserDefaults.standard.set(false, forKey: "BleamPlatformUpdatesSupported")
+        promise.resolve([
+          "healthy": false,
+          "protocolVersion": 1,
+          "helperVersion": "unavailable",
+          "platformVersion": "unavailable",
+          "capabilities": [],
+          "updatesSupported": false,
+          "installPath": Bundle.main.bundleURL.path,
+          "reason": "reinstall_required",
+        ])
+        return
+      }
+      let serviceName = "\(Bundle.main.bundleIdentifier ?? "dev.bleam.app").PlatformHelper"
+      guard let connection = Self.makeConnection(serviceName: serviceName) else {
+        promise.reject("HELPER_UNAVAILABLE", "The app helper is unavailable")
+        return
+      }
+      connection.remoteObjectInterface = NSXPCInterface(with: PlatformHelperProtocol.self)
+      connection.resume()
+
+      guard let service = connection.remoteObjectProxyWithErrorHandler({ error in
+        connection.invalidate()
+        promise.reject("HELPER_UNAVAILABLE", error.localizedDescription)
+      }) as? PlatformHelperProtocol else {
+        connection.invalidate()
+        promise.reject("HELPER_UNAVAILABLE", "The app helper is unavailable")
+        return
+      }
+
+      service.health { data in
+        defer { connection.invalidate() }
+        guard
+          let data,
+          var status = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+          promise.reject("HELPER_INVALID_RESPONSE", "The app helper returned an invalid response")
+          return
+        }
+        let supported = Self.isSupportedInstallLocation
+        status["updatesSupported"] = supported
+        status["installPath"] = Bundle.main.bundleURL.path
+        if !supported {
+          status["reason"] = "reinstall_required"
+        }
+        UserDefaults.standard.set(status["healthy"], forKey: "BleamHelperHealthy")
+        UserDefaults.standard.set(status["platformVersion"], forKey: "BleamHelperPlatformVersion")
+        UserDefaults.standard.set(supported, forKey: "BleamPlatformUpdatesSupported")
+        promise.resolve(status)
+      }
+    }
+
+    AsyncFunction("permissionState") { (capability: String, promise: Promise) in
+      guard let state = Self.permissionState(capability) else {
+        promise.reject("INVALID_CAPABILITY", "Unknown permission capability: \(capability)")
+        return
+      }
+      promise.resolve(Self.permissionResponse(capability: capability, state: state))
+    }
+
+    AsyncFunction("permissionStates") { (promise: Promise) in
+      let states: [[String: Any]] = Self.permissionCapabilities.compactMap { capability in
+        guard let state = Self.permissionState(capability) else { return nil }
+        return Self.permissionResponse(capability: capability, state: state)
+      }
+      promise.resolve(states)
+    }
+
+    AsyncFunction("downloadPlatformUpdate") { (promise: Promise) in
+      guard Self.isSupportedInstallLocation else {
+        promise.reject("REINSTALL_REQUIRED", "Platform updates require the app to be installed directly in ~/Applications")
+        return
+      }
+      guard
+        let serviceURL = Bundle.main.object(forInfoDictionaryKey: "BleamUpdateServiceURL") as? String,
+        let bundleIdentifier = Bundle.main.bundleIdentifier,
+        let teamIdentifier = Bundle.main.object(forInfoDictionaryKey: "BleamTeamIdentifier") as? String,
+        let platformVersion = Bundle.main.object(forInfoDictionaryKey: "BleamRuntimeVersion") as? String,
+        let platformFingerprint = Bundle.main.object(forInfoDictionaryKey: "BleamPlatformFingerprint") as? String,
+        let requestData = try? JSONSerialization.data(withJSONObject: [
+          "serviceURL": serviceURL,
+          "bundleIdentifier": bundleIdentifier,
+          "teamIdentifier": teamIdentifier,
+          "platformVersion": platformVersion,
+          "platformFingerprint": platformFingerprint,
+        ])
+      else {
+        promise.reject("UPDATES_UNAVAILABLE", "Platform updates are not configured")
+        return
+      }
+
+      guard let connection = Self.makeConnection(serviceName: "\(bundleIdentifier).PlatformHelper") else {
+        promise.reject("HELPER_UNAVAILABLE", "The app helper is unavailable")
+        return
+      }
+      connection.remoteObjectInterface = NSXPCInterface(with: PlatformHelperProtocol.self)
+      connection.resume()
+      guard let service = connection.remoteObjectProxyWithErrorHandler({ error in
+        connection.invalidate()
+        promise.reject("PLATFORM_DOWNLOAD_FAILED", error.localizedDescription)
+      }) as? PlatformHelperProtocol else {
+        connection.invalidate()
+        promise.reject("HELPER_UNAVAILABLE", "The app helper is unavailable")
+        return
+      }
+
+      service.downloadPlatformUpdate(requestData: requestData) { data in
+        defer { connection.invalidate() }
+        guard
+          let data,
+          let result = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+          promise.reject("PLATFORM_DOWNLOAD_FAILED", "The platform update could not be downloaded")
+          return
+        }
+        if let error = result["error"] as? String {
+          UserDefaults.standard.set(error, forKey: "BleamPlatformDownloadError")
+          promise.reject("PLATFORM_VERIFICATION_FAILED", error)
+          return
+        }
+        UserDefaults.standard.set(result["releaseId"], forKey: "BleamPlatformDownloadRelease")
+        promise.resolve(result)
+      }
+    }
+
+    AsyncFunction("updateAndRelaunch") { (releaseId: String, promise: Promise) in
+      guard Self.isSupportedInstallLocation else {
+        promise.reject("REINSTALL_REQUIRED", "Platform updates require the app to be installed directly in ~/Applications")
+        return
+      }
+      guard
+        let bundleIdentifier = Bundle.main.bundleIdentifier,
+        let teamIdentifier = Bundle.main.object(forInfoDictionaryKey: "BleamTeamIdentifier") as? String,
+        let requestData = try? JSONSerialization.data(withJSONObject: [
+          "releaseId": releaseId,
+          "bundleIdentifier": bundleIdentifier,
+          "teamIdentifier": teamIdentifier,
+          "installedAppPath": Bundle.main.bundleURL.path,
+          "appPID": ProcessInfo.processInfo.processIdentifier,
+        ]),
+        let connection = Self.makeConnection(serviceName: "\(bundleIdentifier).PlatformHelper")
+      else {
+        promise.reject("PLATFORM_UPDATE_UNAVAILABLE", "The platform update cannot be applied")
+        return
+      }
+      connection.remoteObjectInterface = NSXPCInterface(with: PlatformHelperProtocol.self)
+      connection.resume()
+      guard let service = connection.remoteObjectProxyWithErrorHandler({ error in
+        connection.invalidate()
+        promise.reject("PLATFORM_UPDATE_FAILED", error.localizedDescription)
+      }) as? PlatformHelperProtocol else {
+        connection.invalidate()
+        promise.reject("HELPER_UNAVAILABLE", "The app helper is unavailable")
+        return
+      }
+      service.applyPlatformUpdate(requestData: requestData) { accepted in
+        connection.invalidate()
+        UserDefaults.standard.set(accepted, forKey: "BleamPlatformApplyAccepted")
+        guard accepted else {
+          promise.reject("PLATFORM_UPDATE_REJECTED", "The platform update is not verified or the app is not installed in ~/Applications")
+          return
+        }
+        promise.resolve(nil)
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+          exit(0)
+        }
+      }
+    }
+  }
+
+  private static func makeConnection(serviceName: String) -> NSXPCConnection? {
+#if targetEnvironment(macCatalyst)
+    let connectionClass: AnyObject = NSXPCConnection.self as AnyObject
+    let allocated = connectionClass.perform(NSSelectorFromString("alloc"))?.takeUnretainedValue() as AnyObject?
+    let selector = NSSelectorFromString("initWithMachServiceName:options:")
+    guard let allocated, allocated.responds(to: selector) else { return nil }
+
+    typealias Initializer = @convention(c) (
+      AnyObject,
+      Selector,
+      NSString,
+      UInt
+    ) -> Unmanaged<AnyObject>
+    let initialize = unsafeBitCast(allocated.method(for: selector), to: Initializer.self)
+    return initialize(
+      allocated,
+      selector,
+      serviceName as NSString,
+      0
+    ).takeRetainedValue() as? NSXPCConnection
+#else
+    return NSXPCConnection(machServiceName: serviceName)
+#endif
+  }
+
+  private static let permissionCapabilities = [
+    "camera",
+    "microphone",
+    "photos",
+    "contacts",
+    "calendars",
+    "reminders",
+    "location",
+  ]
+
+  private static func permissionResponse(capability: String, state: String) -> [String: Any] {
+    [
+      "capability": capability,
+      "status": state,
+      "granted": state == "granted" || state == "limited",
+      "canAskAgain": state == "not-determined",
+      "expires": "never",
+    ]
+  }
+
+  private static func permissionState(_ capability: String) -> String? {
+    switch capability {
+    case "camera":
+      return authorizationState(AVCaptureDevice.authorizationStatus(for: .video))
+    case "microphone":
+      return authorizationState(AVCaptureDevice.authorizationStatus(for: .audio))
+    case "photos":
+      switch PHPhotoLibrary.authorizationStatus(for: .readWrite) {
+      case .authorized:
+        return "granted"
+      case .limited:
+        return "limited"
+      case .denied:
+        return "denied"
+      case .restricted:
+        return "restricted"
+      case .notDetermined:
+        return "not-determined"
+      @unknown default:
+        return "unsupported"
+      }
+    case "contacts":
+      switch CNContactStore.authorizationStatus(for: .contacts) {
+      case .authorized:
+        return "granted"
+      case .denied:
+        return "denied"
+      case .restricted:
+        return "restricted"
+      case .notDetermined:
+        return "not-determined"
+      @unknown default:
+        return "unsupported"
+      }
+    case "calendars":
+      return eventAuthorizationState(EKEventStore.authorizationStatus(for: .event))
+    case "reminders":
+      return eventAuthorizationState(EKEventStore.authorizationStatus(for: .reminder))
+    case "location":
+      switch CLLocationManager().authorizationStatus {
+      case .authorizedAlways, .authorizedWhenInUse:
+        return "granted"
+      case .denied:
+        return "denied"
+      case .restricted:
+        return "restricted"
+      case .notDetermined:
+        return "not-determined"
+      @unknown default:
+        return "unsupported"
+      }
+    default:
+      return nil
+    }
+  }
+
+  private static func authorizationState(_ status: AVAuthorizationStatus) -> String {
+    switch status {
+    case .authorized:
+      return "granted"
+    case .denied:
+      return "denied"
+    case .restricted:
+      return "restricted"
+    case .notDetermined:
+      return "not-determined"
+    @unknown default:
+      return "unsupported"
+    }
+  }
+
+  private static func eventAuthorizationState(_ status: EKAuthorizationStatus) -> String {
+    switch status {
+    case .fullAccess, .authorized:
+      return "granted"
+    case .writeOnly:
+      return "limited"
+    case .denied:
+      return "denied"
+    case .restricted:
+      return "restricted"
+    case .notDetermined:
+      return "not-determined"
+    @unknown default:
+      return "unsupported"
+    }
+  }
+
+  private static var isSupportedInstallLocation: Bool {
+    let applications = URL(fileURLWithPath: NSHomeDirectory(), isDirectory: true)
+      .appendingPathComponent("Applications", isDirectory: true).standardizedFileURL
+    return Bundle.main.bundleURL.standardizedFileURL.deletingLastPathComponent() == applications
+  }
+}

package/templates/native/modules/bleam-runtime/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "bleam-runtime",
+  "version": "0.0.0",
+  "private": true
+}

package/templates/native/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "bleam",
+  "version": "1.0.0",
+  "main": "index.ts",
+  "dependencies": {
+    "@nativescript-community/sqlite": "^3.5.9",
+    "@nativescript/react-native": "9.0.0-preview.4",
+    "expo": "~57.0.2",
+    "react": "19.2.3",
+    "react-native": "0.86.0"
+  },
+  "scripts": {
+    "verify": "../../node_modules/.bin/biome check .",
+    "verify:write": "../../node_modules/.bin/biome check --write .",
+    "format": "../../node_modules/.bin/biome format --write .",
+    "format:check": "../../node_modules/.bin/biome format .",
+    "lint": "../../node_modules/.bin/biome lint .",
+    "build:runtime": "xcodebuild -workspace ios/bleam.xcworkspace -scheme Bleam -configuration Debug -destination 'platform=macOS,arch=arm64,variant=Mac Catalyst' -derivedDataPath build ARCHS=arm64 build",
+    "start": "tsx scripts/start/index.ts",
+    "start:clean": "tsx scripts/start/index.ts --clean",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsx": "^4.21.0",
+    "typescript": "7.0.1-rc"
+  },
+  "expo": {
+    "autolinking": {
+      "nativeModulesDir": "modules"
+    },
+    "install": {
+      "exclude": [
+        "typescript"
+      ]
+    }
+  },
+  "private": true
+}