bleam 0.0.8 → 0.0.9

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()

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

@@ -0,0 +1,29 @@
+<?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>BleamPlatformVersion</key>
+	<string>0.0.9</string>
+	<key>XPCService</key>
+	<dict>
+		<key>ServiceType</key>
+		<string>Application</string>
+	</dict>
+</dict>
+</plist>

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

@@ -0,0 +1,335 @@
+import Foundation
+import CryptoKit
+import Security
+import Darwin
+
+@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)
+}
+
+private struct DownloadRequest: Decodable {
+  let serviceURL: URL
+  let bundleIdentifier: String
+  let teamIdentifier: String
+}
+
+private struct ApplyRequest: Decodable {
+  let releaseId: String
+  let bundleIdentifier: String
+  let teamIdentifier: String
+  let installedAppPath: String
+  let appPID: Int32
+}
+
+private struct PlatformRelease: Decodable {
+  struct Artifact: Decodable {
+    let format: String
+    let url: URL
+    let sizeBytes: Int
+    let sha256: String
+  }
+
+  let kind: String
+  let releaseId: String
+  let bundleIdentifier: String
+  let teamIdentifier: String
+  let appVersion: String
+  let buildNumber: String
+  let bleamPlatformVersion: String
+  let target: Target
+  let artifact: Artifact
+
+  struct Target: Decodable {
+    let minimumMacOSVersion: String
+  }
+}
+
+private final class PlatformHelper: NSObject, PlatformHelperProtocol {
+  func health(reply: @escaping (Data?) -> Void) {
+    let response: [String: Any] = [
+      "healthy": true,
+      "protocolVersion": 1,
+      "helperVersion": Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String ?? "unknown",
+      "platformVersion": Bundle.main.object(forInfoDictionaryKey: "BleamPlatformVersion") as? String ?? "unknown",
+      "capabilities": ["platform-updates"],
+    ]
+    reply(try? JSONSerialization.data(withJSONObject: response))
+  }
+
+  func downloadPlatformUpdate(requestData: Data, reply: @escaping (Data?) -> Void) {
+    guard
+      let request = try? JSONDecoder().decode(DownloadRequest.self, from: requestData),
+      let resolverURL = URL(
+        string: "/v1/apps/\(request.bundleIdentifier)/platform/macos-arm64",
+        relativeTo: request.serviceURL
+      )?.absoluteURL
+    else {
+      reply(nil)
+      return
+    }
+
+    URLSession.shared.dataTask(with: resolverURL) { data, response, _ in
+      guard
+        let data,
+        (response as? HTTPURLResponse)?.statusCode == 200,
+        let release = try? JSONDecoder().decode(PlatformRelease.self, from: data),
+        release.kind == "platform",
+        release.bundleIdentifier == request.bundleIdentifier,
+        release.teamIdentifier == request.teamIdentifier,
+        release.artifact.format == "bleam-macos-app-zip-v1",
+        release.releaseId.range(of: "^[a-z][a-z0-9_-]{2,127}$", options: .regularExpression) != nil
+      else {
+        reply(nil)
+        return
+      }
+
+      URLSession.shared.downloadTask(with: release.artifact.url) { temporaryURL, _, _ in
+        guard let temporaryURL else {
+          reply(nil)
+          return
+        }
+
+        do {
+          let cache = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0]
+            .appendingPathComponent("Bleam/Platform", isDirectory: true)
+            .appendingPathComponent(request.bundleIdentifier, isDirectory: true)
+            .appendingPathComponent(release.releaseId, isDirectory: true)
+          let completionReceipt = URL(fileURLWithPath: NSHomeDirectory(), isDirectory: true)
+            .appendingPathComponent("Library/Application Support/Bleam/Updates", isDirectory: true)
+            .appendingPathComponent(request.bundleIdentifier, isDirectory: true)
+            .appendingPathComponent("\(release.releaseId).complete")
+          guard !FileManager.default.fileExists(atPath: completionReceipt.path) else {
+            reply(nil)
+            return
+          }
+          try FileManager.default.createDirectory(at: cache, withIntermediateDirectories: true)
+          let artifactURL = cache.appendingPathComponent("artifact.zip")
+          try? FileManager.default.removeItem(at: artifactURL)
+          try FileManager.default.moveItem(at: temporaryURL, to: artifactURL)
+          let appURL = try self.verify(
+            artifactURL: artifactURL,
+            release: release,
+            request: request,
+            cache: cache
+          )
+          let result: [String: Any] = [
+            "releaseId": release.releaseId,
+            "appVersion": release.appVersion,
+            "buildNumber": release.buildNumber,
+            "platformVersion": release.bleamPlatformVersion,
+            "artifactPath": artifactURL.path,
+            "appPath": appURL.path,
+            "sizeBytes": release.artifact.sizeBytes,
+            "sha256": release.artifact.sha256,
+            "verified": true,
+          ]
+          let receipt: [String: Any] = [
+            "releaseId": release.releaseId,
+            "bundleIdentifier": request.bundleIdentifier,
+            "teamIdentifier": request.teamIdentifier,
+            "appPath": appURL.path,
+          ]
+          let receiptData = try PropertyListSerialization.data(
+            fromPropertyList: receipt,
+            format: .binary,
+            options: 0
+          )
+          try receiptData.write(to: cache.appendingPathComponent("verified.plist"), options: .atomic)
+          reply(try? JSONSerialization.data(withJSONObject: result))
+        } catch {
+          reply(try? JSONSerialization.data(withJSONObject: [
+            "error": String(describing: error),
+          ]))
+        }
+      }.resume()
+    }.resume()
+  }
+
+  func applyPlatformUpdate(requestData: Data, reply: @escaping (Bool) -> Void) {
+    guard
+      let request = try? JSONDecoder().decode(ApplyRequest.self, from: requestData),
+      let installedURL = supportedInstalledURL(path: request.installedAppPath),
+      let candidateURL = verifiedCandidate(request: request)
+    else {
+      reply(false)
+      return
+    }
+
+    reply(true)
+    let activity = ProcessInfo.processInfo.beginActivity(
+      options: [.userInitiated, .idleSystemSleepDisabled, .suddenTerminationDisabled],
+      reason: "Applying a verified Bleam platform update"
+    )
+    DispatchQueue.global(qos: .userInitiated).async {
+      defer { ProcessInfo.processInfo.endActivity(activity) }
+      for _ in 0..<50 where kill(request.appPID, 0) == 0 {
+        usleep(100_000)
+      }
+      if kill(request.appPID, 0) == 0 {
+        _ = kill(request.appPID, SIGTERM)
+        for _ in 0..<50 where kill(request.appPID, 0) == 0 {
+          usleep(100_000)
+        }
+      }
+      guard kill(request.appPID, 0) != 0 else {
+        NSLog("Bleam platform replacement failed: app did not terminate")
+        return
+      }
+
+      let releaseRoot = candidateURL
+        .deletingLastPathComponent().deletingLastPathComponent()
+        .deletingLastPathComponent()
+      let backupURL = releaseRoot.appendingPathComponent("previous.app")
+      do {
+        try? FileManager.default.removeItem(at: backupURL)
+        try FileManager.default.moveItem(at: installedURL, to: backupURL)
+        do {
+          try FileManager.default.moveItem(at: candidateURL, to: installedURL)
+        } catch {
+          try? FileManager.default.moveItem(at: backupURL, to: installedURL)
+          throw error
+        }
+        let receipts = URL(fileURLWithPath: NSHomeDirectory(), isDirectory: true)
+          .appendingPathComponent("Library/Application Support/Bleam/Updates", isDirectory: true)
+          .appendingPathComponent(request.bundleIdentifier, isDirectory: true)
+        try FileManager.default.createDirectory(at: receipts, withIntermediateDirectories: true)
+        try Data().write(to: receipts.appendingPathComponent("\(request.releaseId).complete"))
+        _ = try self.run("/usr/bin/open", [installedURL.path])
+      } catch {
+        NSLog("Bleam platform replacement failed: %@", error.localizedDescription)
+      }
+    }
+  }
+
+  private func supportedInstalledURL(path: String) -> URL? {
+    let applications = URL(fileURLWithPath: NSHomeDirectory(), isDirectory: true)
+      .appendingPathComponent("Applications", isDirectory: true).standardizedFileURL
+    let candidate = URL(fileURLWithPath: path, isDirectory: true).standardizedFileURL
+    guard
+      candidate.deletingLastPathComponent() == applications,
+      candidate.pathExtension == "app"
+    else { return nil }
+    return candidate
+  }
+
+  private func verifiedCandidate(request: ApplyRequest) -> URL? {
+    let root = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0]
+      .appendingPathComponent("Bleam/Platform", isDirectory: true)
+      .appendingPathComponent(request.bundleIdentifier, isDirectory: true)
+      .appendingPathComponent(request.releaseId, isDirectory: true)
+    let receiptURL = root.appendingPathComponent("verified.plist")
+    guard
+      let data = try? Data(contentsOf: receiptURL),
+      let receipt = try? PropertyListSerialization.propertyList(from: data, format: nil) as? [String: String],
+      receipt["releaseId"] == request.releaseId,
+      receipt["bundleIdentifier"] == request.bundleIdentifier,
+      receipt["teamIdentifier"] == request.teamIdentifier,
+      let path = receipt["appPath"]
+    else { return nil }
+    return URL(fileURLWithPath: path, isDirectory: true)
+  }
+
+  private func verify(
+    artifactURL: URL,
+    release: PlatformRelease,
+    request: DownloadRequest,
+    cache: URL
+  ) throws -> URL {
+    let data = try Data(contentsOf: artifactURL, options: .mappedIfSafe)
+    guard
+      data.count == release.artifact.sizeBytes,
+      SHA256.hash(data: data).map({ String(format: "%02x", $0) }).joined() == release.artifact.sha256
+    else { throw VerificationError.invalidArtifact }
+
+    let entries = try run("/usr/bin/zipinfo", ["-1", artifactURL.path])
+      .split(separator: "\n").map(String.init)
+    guard !entries.isEmpty, entries.allSatisfy({ entry in
+      !entry.hasPrefix("/") && entry.split(separator: "/").allSatisfy { $0 != ".." }
+    }) else { throw VerificationError.unsafeArchivePath }
+    let appNames = Set(entries.compactMap { entry -> String? in
+      let parts = entry.split(separator: "/")
+      guard parts.count >= 2, parts[0] == "app", parts[1].hasSuffix(".app") else { return nil }
+      return String(parts[1])
+    })
+    guard
+      appNames.count == 1,
+      let appName = appNames.first,
+      entries.allSatisfy({ $0 == "app/" || $0.hasPrefix("app/\(appName)/") })
+    else { throw VerificationError.invalidArchiveLayout }
+
+    let extracted = cache.appendingPathComponent("extracted", isDirectory: true)
+    try? FileManager.default.removeItem(at: extracted)
+    try FileManager.default.createDirectory(at: extracted, withIntermediateDirectories: true)
+    _ = try run("/usr/bin/ditto", ["-x", "-k", artifactURL.path, extracted.path])
+    let appURL = extracted.appendingPathComponent("app/\(appName)")
+    guard
+      let info = NSDictionary(contentsOf: appURL.appendingPathComponent("Contents/Info.plist")),
+      info["CFBundleIdentifier"] as? String == request.bundleIdentifier,
+      info["CFBundleShortVersionString"] as? String == release.appVersion,
+      info["CFBundleVersion"] as? String == release.buildNumber,
+      let executable = info["CFBundleExecutable"] as? String
+    else { throw VerificationError.invalidIdentity }
+
+    var staticCode: SecStaticCode?
+    guard
+      SecStaticCodeCreateWithPath(appURL as CFURL, [], &staticCode) == errSecSuccess,
+      let staticCode,
+      SecStaticCodeCheckValidity(staticCode, SecCSFlags(rawValue: kSecCSStrictValidate), nil) == errSecSuccess
+    else { throw VerificationError.invalidSignature }
+    var signingInfo: CFDictionary?
+    guard
+      SecCodeCopySigningInformation(staticCode, SecCSFlags(rawValue: kSecCSSigningInformation), &signingInfo) == errSecSuccess,
+      (signingInfo as? [String: Any])?[kSecCodeInfoTeamIdentifier as String] as? String == request.teamIdentifier
+    else { throw VerificationError.invalidSignature }
+
+    let architectures = try run(
+      "/usr/bin/lipo",
+      ["-archs", appURL.appendingPathComponent("Contents/MacOS/\(executable)").path]
+    ).trimmingCharacters(in: .whitespacesAndNewlines)
+    guard architectures == "arm64" else { throw VerificationError.invalidArchitecture }
+
+    let required = release.target.minimumMacOSVersion.split(separator: ".").compactMap { Int($0) }
+    let current = ProcessInfo.processInfo.operatingSystemVersion
+    let installed = [current.majorVersion, current.minorVersion, current.patchVersion]
+    guard installed.lexicographicallyPrecedes(required) == false else {
+      throw VerificationError.unsupportedOS
+    }
+    return appURL
+  }
+
+  private func run(_ executable: String, _ arguments: [String]) throws -> String {
+    let process = Process()
+    let output = Pipe()
+    let errors = Pipe()
+    process.executableURL = URL(fileURLWithPath: executable)
+    process.arguments = arguments
+    process.standardOutput = output
+    process.standardError = errors
+    try process.run()
+    process.waitUntilExit()
+    guard process.terminationStatus == 0 else { throw VerificationError.commandFailed }
+    return String(decoding: output.fileHandleForReading.readDataToEndOfFile(), as: UTF8.self)
+  }
+}
+
+private enum VerificationError: Error {
+  case invalidArtifact, unsafeArchivePath, invalidArchiveLayout, invalidIdentity, invalidSignature
+  case invalidArchitecture, unsupportedOS, commandFailed
+}
+
+private final class PlatformHelperDelegate: NSObject, NSXPCListenerDelegate {
+  func listener(_ listener: NSXPCListener, shouldAcceptNewConnection connection: NSXPCConnection) -> Bool {
+    connection.exportedInterface = NSXPCInterface(with: PlatformHelperProtocol.self)
+    connection.exportedObject = PlatformHelper()
+    connection.resume()
+    return true
+  }
+}
+
+private let delegate = PlatformHelperDelegate()
+private let listener = NSXPCListener.service()
+listener.delegate = delegate
+listener.resume()
+RunLoop.main.run()