bleam 0.0.8 → 0.0.10

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

@@ -0,0 +1,31 @@
+<?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>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>CFBundlePackageType</key>
+	<string>XPC!</string>
+	<key>CFBundleShortVersionString</key>
+	<string>$(MARKETING_VERSION)</string>
+	<key>CFBundleVersion</key>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>AppGroupIdentifier</key>
+	<string>group.dev.bleam.app</string>
+	<key>RCTNewArchEnabled</key>
+	<true/>
+	<key>XPCService</key>
+	<dict>
+		<key>ServiceType</key>
+		<string>Application</string>
+	</dict>
+</dict>
+</plist>

package/templates/native/ios/GenerationService/main.swift

@@ -0,0 +1,165 @@
+import Foundation
+import MLX
+
+private final class GenerationRuntime: @unchecked Sendable {
+  private let modelWarmTimeout: Duration = .seconds(60)
+  private var activeTask: Task<Void, Never>?
+  private var activeRunner: ImageGenerationRunner?
+  private var trimTask: Task<Void, Never>?
+  private var isCancelled = false
+
+  var isRunning: Bool {
+    activeTask != nil
+  }
+
+  func start(
+    request: GenerationWorkerRequest,
+    emit: @escaping @Sendable (GenerationWorkerEvent) -> Void
+  ) -> Bool {
+    guard activeTask == nil else { return false }
+
+    trimTask?.cancel()
+    trimTask = nil
+    isCancelled = false
+    activeTask = Task { [weak self] in
+      await self?.run(request, emit: emit)
+    }
+    return true
+  }
+
+  func cancel() {
+    isCancelled = true
+    trimTask?.cancel()
+    trimTask = nil
+    activeTask?.cancel()
+    activeRunner?.cancel()
+  }
+
+  func trimModelsNow() async {
+    trimTask?.cancel()
+    trimTask = nil
+    // We currently reload every stage per generation, but keep the explicit
+    // trim hook from ImageStudio's service architecture. Warm model caching
+    // should be added here later, never back in the app process.
+    MLX.Memory.clearCache()
+    await Task.yield()
+    MLX.Memory.clearCache()
+    print("[GenerationService] trim active=\(MLX.Memory.activeMemory / 1_048_576)MB cache=\(MLX.Memory.cacheMemory / 1_048_576)MB")
+  }
+
+  private func run(
+    _ request: GenerationWorkerRequest,
+    emit: @escaping @Sendable (GenerationWorkerEvent) -> Void
+  ) async {
+    let runner = ImageGenerationRunner(request: request, emit: emit)
+    activeRunner = runner
+    defer {
+      if activeRunner === runner {
+        activeRunner = nil
+      }
+      activeTask = nil
+      scheduleTrimAfterIdle()
+    }
+
+    do {
+      try await runner.run(isCancelled: { [weak self] in
+        Task.isCancelled || (self?.isCancelled ?? false)
+      })
+    } catch is CancellationError {
+      emit(.init(type: .canceled))
+    } catch let failure as GenerationWorkerFailure {
+      print("[GenerationService] failed - \(failure.localizedDescription)")
+      emit(.init(type: .failed, message: failure.localizedDescription, stage: failure.stage))
+    } catch {
+      print("[GenerationService] failed - \(error.localizedDescription)")
+      emit(.init(type: .failed, message: error.localizedDescription))
+    }
+  }
+
+  private func scheduleTrimAfterIdle() {
+    trimTask?.cancel()
+    trimTask = Task { [weak self] in
+      guard let self else { return }
+      do {
+        try await Task.sleep(for: modelWarmTimeout)
+      } catch {
+        return
+      }
+      guard !Task.isCancelled else { return }
+      await self.trimModelsNow()
+    }
+    print("[GenerationService] model trim scheduled 60s")
+  }
+}
+
+private final class GenerationService: NSObject, GenerationServiceProtocol {
+  private weak var connection: NSXPCConnection?
+  private let runtime = GenerationRuntime()
+
+  init(connection: NSXPCConnection) {
+    self.connection = connection
+  }
+
+  func startGeneration(requestData: Data, reply: @escaping (Bool) -> Void) {
+    guard let request = try? JSONDecoder().decode(GenerationWorkerRequest.self, from: requestData) else {
+      emit(.init(type: .failed, message: "Invalid generation request."))
+      reply(false)
+      return
+    }
+
+    reply(runtime.start(request: request) { [weak self] event in
+      self?.emit(event)
+    })
+  }
+
+  func cancelGeneration(reply: @escaping (Bool) -> Void) {
+    runtime.cancel()
+    reply(true)
+  }
+
+  func memoryTelemetry(reply: @escaping (Data?) -> Void) {
+    let value: [String: Any] = [
+      "activeMB": Double(MLX.Memory.activeMemory) / 1_048_576,
+      "cacheMB": Double(MLX.Memory.cacheMemory) / 1_048_576,
+    ]
+    reply(try? JSONSerialization.data(withJSONObject: value))
+  }
+
+  func shutdown(reply: @escaping (Bool) -> Void) {
+    guard !runtime.isRunning else {
+      reply(false)
+      return
+    }
+    Task { [runtime] in
+      await runtime.trimModelsNow()
+      reply(true)
+      exit(0)
+    }
+  }
+
+  private func emit(_ event: GenerationWorkerEvent) {
+    guard let data = try? JSONEncoder().encode(event) else { return }
+    let client = connection?.remoteObjectProxy as? GenerationServiceClientProtocol
+    client?.generationWorkerDidEmit(eventData: data)
+  }
+}
+
+private final class GenerationServiceDelegate: NSObject, NSXPCListenerDelegate {
+  func listener(_ listener: NSXPCListener, shouldAcceptNewConnection connection: NSXPCConnection) -> Bool {
+    connection.exportedInterface = NSXPCInterface(with: GenerationServiceProtocol.self)
+    connection.remoteObjectInterface = NSXPCInterface(with: GenerationServiceClientProtocol.self)
+    connection.exportedObject = GenerationService(connection: connection)
+    connection.resume()
+    return true
+  }
+}
+
+// Heavy MLX generation is intentionally isolated in this XPC service. If model
+// loading or Metal memory pressure takes the service down, the app shell can
+// reconnect or report failure instead of dying with the generation process.
+private let delegate = GenerationServiceDelegate()
+private let listener = NSXPCListener.service()
+listener.delegate = delegate
+listener.resume()
+
+RunLoop.main.run()