@otakit/capacitor-updater 1.0.0

package/ios/Sources/UpdaterPlugin/Downloader.swift

@@ -0,0 +1,120 @@
+import Foundation
+
+final class Downloader {
+  private let allowInsecureUrls: Bool
+
+  init(allowInsecureUrls: Bool = false) {
+    self.allowInsecureUrls = allowInsecureUrls
+  }
+
+  func download(
+    from url: URL,
+    progress: @escaping (Double, Int64, Int64) -> Void = { _, _, _ in }
+  ) async throws -> URL {
+    try ManifestClient.requireHTTPS(url: url, allowInsecure: allowInsecureUrls)
+    let delegate = DownloadDelegate(progressHandler: progress)
+    return try await delegate.start(from: url)
+  }
+}
+
+private final class DownloadDelegate: NSObject, URLSessionDownloadDelegate {
+  private var continuation: CheckedContinuation<URL, Error>?
+  private var session: URLSession?
+  private let progressHandler: (Double, Int64, Int64) -> Void
+  private let stateLock = NSLock()
+  private var isResolved = false
+
+  init(progressHandler: @escaping (Double, Int64, Int64) -> Void) {
+    self.progressHandler = progressHandler
+    super.init()
+  }
+
+  func start(from url: URL) async throws -> URL {
+    try await withCheckedThrowingContinuation { continuation in
+      self.continuation = continuation
+
+      let configuration = URLSessionConfiguration.default
+      let session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
+      self.session = session
+      let task = session.downloadTask(with: url)
+      task.resume()
+    }
+  }
+
+  private func resolve(_ result: Result<URL, Error>) {
+    stateLock.lock()
+    guard !isResolved, let continuation else {
+      stateLock.unlock()
+      return
+    }
+    isResolved = true
+    self.continuation = nil
+    stateLock.unlock()
+
+    switch result {
+    case let .success(url):
+      continuation.resume(returning: url)
+    case let .failure(error):
+      continuation.resume(throwing: error)
+    }
+  }
+
+  func urlSession(
+    _ session: URLSession,
+    downloadTask: URLSessionDownloadTask,
+    didFinishDownloadingTo location: URL
+  ) {
+    // Check HTTP status before treating the file as a valid download
+    if let httpResponse = downloadTask.response as? HTTPURLResponse,
+       !(200..<300).contains(httpResponse.statusCode) {
+      resolve(.failure(NSError(
+        domain: "Downloader",
+        code: httpResponse.statusCode,
+        userInfo: [NSLocalizedDescriptionKey: "Download failed with HTTP \(httpResponse.statusCode)"]
+      )))
+      session.finishTasksAndInvalidate()
+      self.session = nil
+      return
+    }
+
+    let temporaryZip = FileManager.default.temporaryDirectory
+      .appendingPathComponent("updatekit-\(UUID().uuidString).zip")
+
+    do {
+      try FileManager.default.moveItem(at: location, to: temporaryZip)
+      resolve(.success(temporaryZip))
+    } catch {
+      resolve(.failure(error))
+    }
+
+    session.finishTasksAndInvalidate()
+    self.session = nil
+  }
+
+  func urlSession(
+    _ session: URLSession,
+    downloadTask: URLSessionDownloadTask,
+    didWriteData bytesWritten: Int64,
+    totalBytesWritten: Int64,
+    totalBytesExpectedToWrite: Int64
+  ) {
+    guard totalBytesExpectedToWrite > 0 else {
+      return
+    }
+    let percent = (Double(totalBytesWritten) / Double(totalBytesExpectedToWrite)) * 100
+    progressHandler(percent, totalBytesWritten, totalBytesExpectedToWrite)
+  }
+
+  func urlSession(
+    _ session: URLSession,
+    task: URLSessionTask,
+    didCompleteWithError error: Error?
+  ) {
+    if let error {
+      resolve(.failure(error))
+    }
+
+    session.finishTasksAndInvalidate()
+    self.session = nil
+  }
+}

package/ios/Sources/UpdaterPlugin/HashUtils.swift

@@ -0,0 +1,33 @@
+import CryptoKit
+import Foundation
+
+enum HashUtilsError: Error {
+  case couldNotOpenFile
+}
+
+enum HashUtils {
+  static func sha256(fileURL: URL) throws -> String {
+    guard let handle = try? FileHandle(forReadingFrom: fileURL) else {
+      throw HashUtilsError.couldNotOpenFile
+    }
+    defer { try? handle.close() }
+
+    var hasher = SHA256()
+
+    while autoreleasepool(invoking: {
+      let data = handle.readData(ofLength: 1024 * 1024)
+      if data.isEmpty {
+        return false
+      }
+      hasher.update(data: data)
+      return true
+    }) {}
+
+    return hasher.finalize().map { String(format: "%02x", $0) }.joined()
+  }
+
+  static func verify(fileURL: URL, expectedSha256: String) throws -> Bool {
+    let actual = try sha256(fileURL: fileURL)
+    return actual.lowercased() == expectedSha256.lowercased()
+  }
+}

package/ios/Sources/UpdaterPlugin/HostedManifestKeys.swift

@@ -0,0 +1,23 @@
+import Foundation
+
+enum HostedManifestKeys {
+  static let managedServerURL = "https://www.otakit.app/api/v1"
+
+  static let defaults: [(kid: String, key: Data)] = [
+    (
+      kid: "hosted-2026-04-02-ce611e6d",
+      key: Data(
+        base64Encoded: "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAELg6eAj2+7aZ1FJnYUNMjOtWuQLJMomXkPvmeTQ3gXyabpLTDX0m3iWYO3cEOXqIR6NphGC6csS2T5bCtXwIBFw=="
+      )!
+    )
+  ]
+
+  static func matchesManagedServer(_ updateUrl: String) -> Bool {
+    let normalized = updateUrl
+      .trimmingCharacters(in: .whitespacesAndNewlines)
+      .replacingOccurrences(of: "/+$", with: "", options: .regularExpression)
+      .lowercased()
+    return normalized == managedServerURL
+        || normalized == "https://otakit.app/api/v1"
+  }
+}

package/ios/Sources/UpdaterPlugin/ManifestClient.swift

@@ -0,0 +1,161 @@
+import Foundation
+
+struct LatestManifest {
+  let version: String
+  let url: String
+  let sha256: String
+  let size: Int
+  let minNativeBuild: Int?
+  let releaseId: String?
+  let signature: ManifestSignature?
+}
+
+struct ManifestSignature {
+  let kid: String
+  let sig: String
+  let iat: Int
+  let exp: Int
+}
+
+enum ManifestClientError: Error {
+  case invalidURL
+  case invalidResponse
+  case requestFailed(String)
+  case insecureURL(String)
+}
+
+enum ManifestClient {
+
+  static func requireHTTPS(url: URL, allowInsecure: Bool) throws {
+    let scheme = url.scheme?.lowercased() ?? ""
+    if scheme == "https" { return }
+    if allowInsecure {
+      let host = url.host?.lowercased() ?? ""
+      if host == "localhost" || host == "127.0.0.1" { return }
+    }
+    throw ManifestClientError.insecureURL(
+      "URL must use HTTPS: \(url.absoluteString)"
+    )
+  }
+
+  static func fetchLatest(
+    updateUrl: String,
+    appId: String,
+    channel: String?,
+    currentVersion: String,
+    currentReleaseId: String?,
+    nativeBuild: String,
+    platform: String,
+    allowInsecureUrls: Bool = false,
+    manifestKeys: [ManifestKey] = []
+  ) async throws -> LatestManifest? {
+    let sanitizedBase = updateUrl.replacingOccurrences(
+      of: "/+$",
+      with: "",
+      options: .regularExpression
+    )
+
+    guard let baseURL = URL(string: sanitizedBase) else {
+      throw ManifestClientError.invalidURL
+    }
+    let url = baseURL.appendingPathComponent("manifest")
+
+    try requireHTTPS(url: url, allowInsecure: allowInsecureUrls)
+
+    var request = URLRequest(url: url)
+    request.httpMethod = "GET"
+    request.setValue(appId, forHTTPHeaderField: "X-App-Id")
+    request.setValue(platform, forHTTPHeaderField: "X-Platform")
+    if let channel, !channel.isEmpty {
+      request.setValue(channel, forHTTPHeaderField: "X-Channel")
+    }
+    request.setValue(currentVersion, forHTTPHeaderField: "X-Current-Version")
+    if let currentReleaseId, !currentReleaseId.isEmpty {
+      request.setValue(currentReleaseId, forHTTPHeaderField: "X-Release-Id")
+    }
+    request.setValue(nativeBuild, forHTTPHeaderField: "X-Native-Build")
+    request.timeoutInterval = 30
+
+    let (data, response) = try await URLSession.shared.data(for: request)
+    guard let httpResponse = response as? HTTPURLResponse else {
+      throw ManifestClientError.invalidResponse
+    }
+
+    if httpResponse.statusCode == 204 {
+      return nil
+    }
+
+    guard httpResponse.statusCode == 200 else {
+      let body = String(data: data, encoding: .utf8) ?? "unknown"
+      throw ManifestClientError.requestFailed(
+        "HTTP \(httpResponse.statusCode): \(body)"
+      )
+    }
+
+    guard
+      let object = try JSONSerialization.jsonObject(with: data) as? [String: Any],
+      let version = object["version"] as? String,
+      let downloadUrl = object["url"] as? String,
+      let sha256 = object["sha256"] as? String,
+      let size = object["size"] as? Int
+    else {
+      throw ManifestClientError.invalidResponse
+    }
+
+    var minNativeBuild: Int?
+    if let numeric = object["minNativeBuild"] as? NSNumber {
+      minNativeBuild = numeric.intValue
+    } else if let stringValue = object["minNativeBuild"] as? String {
+      minNativeBuild = Int(stringValue)
+    }
+
+    var signature: ManifestSignature?
+    if let sigObj = object["signature"] as? [String: Any],
+       let kid = sigObj["kid"] as? String,
+       let sig = sigObj["sig"] as? String,
+       let iat = sigObj["iat"] as? Int,
+       let exp = sigObj["exp"] as? Int {
+      signature = ManifestSignature(kid: kid, sig: sig, iat: iat, exp: exp)
+    }
+
+    let releaseId = object["releaseId"] as? String
+
+    // Validate download URL scheme
+    guard let dlURL = URL(string: downloadUrl) else {
+      throw ManifestClientError.invalidURL
+    }
+    try requireHTTPS(url: dlURL, allowInsecure: allowInsecureUrls)
+
+    if manifestKeys.isEmpty {
+      print("[UpdateKit] WARNING: No manifest signing keys configured — signature verification is disabled for this request.")
+    }
+
+    // Verify manifest signature if signing keys are configured
+    if !manifestKeys.isEmpty {
+      guard let sig = signature else {
+        throw ManifestVerifierError.missingSignature
+      }
+      try ManifestVerifier.verify(
+        appId: appId,
+        channel: channel,
+        platform: platform,
+        version: version,
+        sha256: sha256,
+        size: size,
+        minNativeBuild: minNativeBuild,
+        signature: sig,
+        trustedKeys: manifestKeys
+      )
+    }
+
+    return LatestManifest(
+      version: version,
+      url: downloadUrl,
+      sha256: sha256,
+      size: size,
+      minNativeBuild: minNativeBuild,
+      releaseId: releaseId,
+      signature: signature
+    )
+  }
+}

package/ios/Sources/UpdaterPlugin/ManifestVerifier.swift

@@ -0,0 +1,115 @@
+import CryptoKit
+import Foundation
+
+struct ManifestKey {
+  let kid: String
+  let derData: Data
+}
+
+enum ManifestVerifierError: Error {
+  case unknownKid(String)
+  case expired
+  case invalidSignature
+  case missingSignature
+}
+
+enum ManifestVerifier {
+
+  /// Verify a manifest signature using ES256 (ECDSA P-256 + SHA-256).
+  ///
+  /// - Parameters:
+  ///   - appId, channel, platform: Request context (known by plugin).
+  ///   - version, sha256, size, minNativeBuild: Response fields.
+  ///   - signature: The signature object from the manifest response.
+  ///   - trustedKeys: Array of verification keys configured in the plugin.
+  ///
+  /// - Throws: `ManifestVerifierError` on failure.
+  static func verify(
+    appId: String,
+    channel: String?,
+    platform: String,
+    version: String,
+    sha256: String,
+    size: Int,
+    minNativeBuild: Int?,
+    signature: ManifestSignature,
+    trustedKeys: [ManifestKey]
+  ) throws {
+    // Check expiry
+    let now = Int(Date().timeIntervalSince1970)
+    guard signature.exp > now else {
+      throw ManifestVerifierError.expired
+    }
+
+    // Find matching key
+    guard let keyEntry = trustedKeys.first(where: { $0.kid == signature.kid }) else {
+      throw ManifestVerifierError.unknownKid(signature.kid)
+    }
+
+    // Build canonical payload (must match server exactly)
+    let payload = buildCanonicalPayload(
+      appId: appId,
+      channel: channel,
+      platform: platform,
+      version: version,
+      sha256: sha256,
+      size: size,
+      minNativeBuild: minNativeBuild,
+      kid: signature.kid,
+      iat: signature.iat,
+      exp: signature.exp
+    )
+
+    // Decode base64url signature
+    guard let sigData = base64UrlDecode(signature.sig) else {
+      throw ManifestVerifierError.invalidSignature
+    }
+
+    // Verify with CryptoKit
+    let verificationKey = try P256.Signing.PublicKey(derRepresentation: keyEntry.derData)
+    let payloadData = Data(payload.utf8)
+    let ecdsaSignature = try P256.Signing.ECDSASignature(derRepresentation: sigData)
+    guard verificationKey.isValidSignature(ecdsaSignature, for: payloadData) else {
+      throw ManifestVerifierError.invalidSignature
+    }
+  }
+
+  private static func buildCanonicalPayload(
+    appId: String,
+    channel: String?,
+    platform: String,
+    version: String,
+    sha256: String,
+    size: Int,
+    minNativeBuild: Int?,
+    kid: String,
+    iat: Int,
+    exp: Int
+  ) -> String {
+    let minBuildStr = minNativeBuild.map { String($0) } ?? "null"
+    return [
+      "MANIFEST_V1",
+      "appId:\(appId)",
+      "channel:\(channel ?? "null")",
+      "platform:\(platform)",
+      "version:\(version)",
+      "sha256:\(sha256)",
+      "size:\(size)",
+      "minNativeBuild:\(minBuildStr)",
+      "kid:\(kid)",
+      "iat:\(iat)",
+      "exp:\(exp)",
+    ].joined(separator: "\n")
+  }
+
+  private static func base64UrlDecode(_ string: String) -> Data? {
+    var base64 = string
+      .replacingOccurrences(of: "-", with: "+")
+      .replacingOccurrences(of: "_", with: "/")
+    let remainder = base64.count % 4
+    if remainder > 0 {
+      base64 += String(repeating: "=", count: 4 - remainder)
+    }
+    return Data(base64Encoded: base64)
+  }
+}

package/ios/Sources/UpdaterPlugin/StatsClient.swift

@@ -0,0 +1,66 @@
+import Foundation
+
+enum StatsAction: String {
+    case downloaded
+    case applied
+    case downloadError = "download_error"
+    case rollback
+}
+
+enum StatsClient {
+    static func send(
+        updateUrl: String,
+        appId: String,
+        platform: String,
+        action: StatsAction,
+        bundleVersion: String?,
+        channel: String?,
+        releaseId: String?,
+        nativeBuild: String?,
+        errorMessage: String?
+    ) {
+        let sanitizedBase = updateUrl.replacingOccurrences(
+            of: "/+$",
+            with: "",
+            options: .regularExpression
+        )
+
+        guard let url = URL(string: "\(sanitizedBase)/stats") else {
+            return
+        }
+
+        var payload: [String: Any] = [
+            "platform": platform,
+            "action": action.rawValue,
+        ]
+        if let bundleVersion {
+            payload["bundleVersion"] = bundleVersion
+        }
+        if let channel, !channel.isEmpty {
+            payload["channel"] = channel
+        }
+        if let releaseId, !releaseId.isEmpty {
+            payload["releaseId"] = releaseId
+        }
+        if let nativeBuild {
+            payload["nativeBuild"] = nativeBuild
+        }
+        if let errorMessage {
+            payload["errorMessage"] = String(errorMessage.prefix(500))
+        }
+
+        guard let body = try? JSONSerialization.data(withJSONObject: payload) else {
+            return
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue(appId, forHTTPHeaderField: "X-App-Id")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.httpBody = body
+        request.timeoutInterval = 10
+
+        // Fire and forget - don't block on response
+        URLSession.shared.dataTask(with: request).resume()
+    }
+}

package/ios/Sources/UpdaterPlugin/UpdaterPlugin.m

@@ -0,0 +1,15 @@
+#import <Capacitor/Capacitor.h>
+
+CAP_PLUGIN(UpdaterPlugin, "OtaKit",
+  CAP_PLUGIN_METHOD(check, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(download, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(apply, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(debugGetState, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(debugCheck, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(debugDownload, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(notifyAppReady, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(debugReset, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(debugListBundles, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(debugDeleteBundle, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(debugGetLastFailure, CAPPluginReturnPromise);
+)