@_nazmiforreal/flutter-ota 0.1.0 → 0.1.1

package/dart-src/plugins/cloudflare/lib/src/r2_s3_client.dart

@@ -0,0 +1,287 @@
+import 'dart:convert' show utf8;
+import 'dart:io' show File;
+import 'dart:typed_data' show Uint8List;
+
+import 'package:crypto/crypto.dart' show Hmac, sha256;
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show StorageObject;
+import 'package:http/http.dart' show Client, Request, Response;
+
+import 'r2_config.dart' show R2S3StorageConfig;
+
+/// A thin S3-compatible client for Cloudflare R2.
+///
+/// Mirrors the subset of `@aws-sdk/client-s3` used by hot-updater's
+/// `r2S3Storage.ts`: delete / put / head / get objects, listing, and
+/// presigned GET URLs. Requests are signed with AWS Signature V4.
+abstract class R2S3ClientLike {
+  const R2S3ClientLike();
+
+  Future<void> deleteObject(String key);
+
+  Future<void> putObject(String key, List<int> body, String contentType);
+
+  Future<bool> headObject(String key);
+
+  Future<List<int>> getObjectAsBytes(String key);
+
+  Future<String> getObjectAsString(String key);
+
+  Future<String> getSignedUrl(String key, {int expiresIn = 3600});
+
+  Future<List<StorageObject>> listObjects([String? prefix]);
+
+  Future<void> deleteObjects(List<String> keys);
+}
+
+/// Real R2 S3 client backed by `package:http` + AWS SigV4 signing.
+class R2S3Client implements R2S3ClientLike {
+  R2S3Client(this.config, {Client? http}) : _http = http ?? Client();
+
+  final R2S3StorageConfig config;
+  final Client _http;
+
+  static const String _service = 'r2';
+
+  Uri _objectUri(String key) {
+    final host = config.endpoint ??
+        'https://${config.accountId}.r2.cloudflarestorage.com';
+    return Uri.parse('$host/${config.bucketName}/$key');
+  }
+
+  @override
+  Future<void> deleteObject(String key) async {
+    final response = await _send('DELETE', _objectUri(key), body: null);
+    _assertStatus(response, [200, 204], 'deleteObject');
+  }
+
+  @override
+  Future<void> putObject(
+    String key,
+    List<int> body,
+    String contentType,
+  ) async {
+    final uri = _objectUri(key);
+    final response = await _send(
+      'PUT',
+      uri,
+      body: body,
+      extraHeaders: {
+        'Content-Type': contentType,
+        'Cache-Control': 'max-age=31536000',
+      },
+    );
+    _assertStatus(response, [200], 'putObject');
+  }
+
+  @override
+  Future<bool> headObject(String key) async {
+    final uri = _objectUri(key);
+    final request = Request('HEAD', uri)..headers.addAll(_authHeaders('HEAD', uri, null));
+    final response = await _http.send(request);
+    if (response.statusCode == 404) return false;
+    if (response.statusCode < 200 || response.statusCode >= 300) {
+      throw Exception('R2 HeadObject failed (${response.statusCode})');
+    }
+    return true;
+  }
+
+  @override
+  Future<List<int>> getObjectAsBytes(String key) async {
+    final response = await _send('GET', _objectUri(key), body: null);
+    _assertStatus(response, [200], 'getObjectAsBytes');
+    return response.bodyBytes;
+  }
+
+  @override
+  Future<String> getObjectAsString(String key) async {
+    final bytes = await getObjectAsBytes(key);
+    return utf8.decode(bytes);
+  }
+
+  @override
+  Future<String> getSignedUrl(String key, {int expiresIn = 3600}) async {
+    final uri = _objectUri(key);
+    final now = DateTime.now().toUtc();
+    final amzDate = _amzDate(now);
+    final dateStamp = amzDate.substring(0, 8);
+    final scope = '$dateStamp/${config.region}/$_service/aws4_request';
+
+    final params = {
+      'X-Amz-Algorithm': 'AWS4-HMAC-SHA256',
+      'X-Amz-Credential': '${config.accessKeyId}/$scope',
+      'X-Amz-Date': amzDate,
+      'X-Amz-Expires': '$expiresIn',
+      'X-Amz-SignedHeaders': 'host',
+    };
+    final canonicalQuery = params.entries
+        .map((e) => '${_uriEncode(e.key)}=${_uriEncode(e.value)}')
+        .toList()
+      ..sort();
+    final queryString = canonicalQuery.join('&');
+
+    const payloadHash = 'UNSIGNED-PAYLOAD';
+    final canonicalHeaders = 'host:${uri.host}\n';
+    final canonicalRequest =
+        'GET\n${uri.path}\n$queryString\n$canonicalHeaders\nhost\n$payloadHash';
+    final stringToSign = _stringToSign(
+      amzDate,
+      scope,
+      canonicalRequest,
+    );
+    final signingKey = _signingKey(dateStamp, config.region);
+    final signature = _toHex(_hmac(signingKey, stringToSign));
+    return '${uri.scheme}://${uri.host}${uri.path}?$queryString'
+        '&X-Amz-Signature=$signature';
+  }
+
+  @override
+  Future<List<StorageObject>> listObjects([String? prefix]) async {
+    final base = _objectUri('').replace(path: '/${config.bucketName}/');
+    final listUri = base.replace(
+      queryParameters: {
+        'list-type': '2',
+        if (prefix != null && prefix.isNotEmpty) 'prefix': prefix,
+      },
+    );
+    final response = await _send('GET', listUri, body: null);
+    _assertStatus(response, [200], 'listObjects');
+    return _parseListObjects(response.body);
+  }
+
+  @override
+  Future<void> deleteObjects(List<String> keys) async {
+    for (final key in keys) {
+      await deleteObject(key);
+    }
+  }
+
+  // --- signing helpers -------------------------------------------------------
+
+  Map<String, String> _authHeaders(
+    String method,
+    Uri uri,
+    List<int>? body,
+  ) {
+    final now = DateTime.now().toUtc();
+    final amzDate = _amzDate(now);
+    final dateStamp = amzDate.substring(0, 8);
+    final scope = '$dateStamp/${config.region}/$_service/aws4_request';
+    final payloadHash = body == null ? _hashHex(const []) : _hashHex(body);
+
+    final canonicalHeaders = 'host:${uri.host}\n'
+        'x-amz-content-sha256:$payloadHash\n'
+        'x-amz-date:$amzDate\n';
+    const signedHeaders = 'host;x-amz-content-sha256;x-amz-date';
+
+    final canonicalRequest = '$method\n${uri.path}\n'
+        '\n$canonicalHeaders$signedHeaders\n$payloadHash';
+    final stringToSign = _stringToSign(amzDate, scope, canonicalRequest);
+    final signingKey = _signingKey(dateStamp, config.region);
+    final signature = _toHex(_hmac(signingKey, stringToSign));
+
+    return {
+      'x-amz-date': amzDate,
+      'x-amz-content-sha256': payloadHash,
+      'Authorization':
+          'AWS4-HMAC-SHA256 Credential=${config.accessKeyId}/$scope, '
+          'SignedHeaders=$signedHeaders, Signature=$signature',
+    };
+  }
+
+  Future<Response> _send(
+    String method,
+    Uri uri, {
+    required List<int>? body,
+    Map<String, String>? extraHeaders,
+  }) async {
+    final request = Request(method, uri);
+    request.headers.addAll(_authHeaders(method, uri, body));
+    if (extraHeaders != null) request.headers.addAll(extraHeaders);
+    if (body != null) request.bodyBytes = body;
+    final streamed = await _http.send(request);
+    return await Response.fromStream(streamed);
+  }
+
+  List<StorageObject> _parseListObjects(String xml) {
+    final objects = <StorageObject>[];
+    final contents = _allMatches(xml, RegExp(r'<Contents>([\s\S]*?)</Contents>'));
+    for (final block in contents) {
+      final key = _tag(block, 'Key');
+      final size = int.tryParse(_tag(block, 'Size') ?? '');
+      final lastModified = _tag(block, 'LastModified');
+      if (key == null) continue;
+      objects.add(
+        StorageObject(
+          key: key,
+          storageUri: 'r2://${config.bucketName}/$key',
+          size: size ?? 0,
+          lastModifiedAt: lastModified == null
+              ? null
+              : DateTime.tryParse(lastModified),
+        ),
+      );
+    }
+    return objects;
+  }
+
+  // --- low-level sigv4 primitives --------------------------------------------
+
+  List<int> _signingKey(String dateStamp, String region) {
+    var key = utf8.encode('AWS4${config.secretAccessKey}');
+    key = _hmac(key, dateStamp);
+    key = _hmac(key, region);
+    key = _hmac(key, _service);
+    key = _hmac(key, 'aws4_request');
+    return key;
+  }
+
+  String _stringToSign(String amzDate, String scope, String canonicalRequest) =>
+      'AWS4-HMAC-SHA256\n$amzDate\n$scope\n${_hashHex(utf8.encode(canonicalRequest))}';
+
+  // --- static utilities ------------------------------------------------------
+
+  static String _amzDate(DateTime utc) =>
+      '${utc.toIso8601String().replaceAll('-', '').replaceAll(':', '').split('.').first}Z';
+
+  static String _uriEncode(String value) => Uri.encodeQueryComponent(value);
+
+  static Uint8List _hmac(List<int> key, String data) =>
+      Hmac(sha256, key).convert(utf8.encode(data)).bytes as Uint8List;
+
+  static String _hashHex(List<int> data) => _toHex(sha256.convert(data).bytes);
+
+  static String _toHex(List<int> bytes) =>
+      bytes.map((b) => b.toRadixString(16).padLeft(2, '0')).join();
+
+  static List<String> _allMatches(String input, RegExp regex) =>
+      regex.allMatches(input).map((m) => m.group(1)!).toList();
+
+  static String? _tag(String block, String name) {
+    final m = RegExp('<$name>([\\s\\S]*?)</$name>').firstMatch(block);
+    return m?.group(1);
+  }
+
+  static void _assertStatus(
+    Response response,
+    List<int> ok,
+    String operation,
+  ) {
+    if (!ok.contains(response.statusCode)) {
+      throw Exception(
+        'R2 $operation failed (${response.statusCode}): ${response.body}',
+      );
+    }
+  }
+}
+
+/// Read a local file's bytes (node profile helper).
+Future<List<int>> readFileBytes(String filePath) =>
+    File(filePath).readAsBytes();
+
+/// Write bytes to a local file, creating parent directories.
+Future<void> writeFileBytes(String filePath, List<int> bytes) async {
+  final file = File(filePath);
+  await file.parent.create(recursive: true);
+  await file.writeAsBytes(bytes);
+}

package/dart-src/plugins/cloudflare/lib/src/r2_storage.dart

@@ -0,0 +1,23 @@
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show StoragePlugin, createUniversalStoragePlugin;
+
+import 'r2_config.dart' show R2S3StorageConfig;
+import 'r2_storage_profile.dart'
+    show createS3RuntimeStorageProfile, createS3StorageProfile;
+
+/// Cloudflare R2 storage plugin (faithful port of hot-updater's `r2Storage`).
+///
+/// Uses the S3-compatible R2 API (AWS Signature V4). The node profile handles
+/// upload/delete/download/list; the runtime profile serves presigned download
+/// URLs and reads small text objects. Note: hot-updater also supports a
+/// deprecated Wrangler-CLI based profile; only the S3-compatible profile is
+/// ported here.
+final StoragePlugin Function(R2S3StorageConfig config) r2Storage =
+    createUniversalStoragePlugin<R2S3StorageConfig>(
+  name: 'r2Storage',
+  supportedProtocol: 'r2',
+  factory: (config) => (
+    node: createS3StorageProfile(config),
+    runtime: createS3RuntimeStorageProfile(config),
+  ),
+);

package/dart-src/plugins/cloudflare/lib/src/r2_storage_profile.dart

@@ -0,0 +1,110 @@
+import 'package:path/path.dart' show basename;
+
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show
+        NodeStorageProfile,
+        RuntimeStorageProfile,
+        StorageObject,
+        createStorageKeyBuilder,
+        getContentType,
+        parseStorageUri;
+
+import 'r2_config.dart' show R2S3StorageConfig, resolveR2Client;
+import 'r2_s3_client.dart' show R2S3ClientLike, readFileBytes, writeFileBytes;
+
+void _ensureExpectedBucket(String bucket, String bucketName) {
+  if (bucket != bucketName) {
+    throw ArgumentError(
+      'Bucket name mismatch: expected "$bucketName", but found "$bucket".',
+    );
+  }
+}
+
+/// Build the node (deploy/CLI) storage profile for R2 S3.
+NodeStorageProfile createS3StorageProfile(R2S3StorageConfig config) {
+  final R2S3ClientLike client = resolveR2Client(config);
+  final getStorageKey = createStorageKeyBuilder(config.basePath);
+
+  return _R2NodeProfile(client, config, getStorageKey);
+}
+
+/// Build the runtime (update-check) storage profile for R2 S3.
+RuntimeStorageProfile createS3RuntimeStorageProfile(R2S3StorageConfig config) {
+  final R2S3ClientLike client = resolveR2Client(config);
+  return _R2RuntimeProfile(client, config);
+}
+
+class _R2NodeProfile implements NodeStorageProfile {
+  _R2NodeProfile(this._client, this._config, this._getStorageKey);
+
+  final R2S3ClientLike _client;
+  final R2S3StorageConfig _config;
+  final String Function(String, [String, String, String]) _getStorageKey;
+
+  @override
+  Future<Map<String, String>> upload(String key, String filePath) async {
+    final bytes = await readFileBytes(filePath);
+    final contentType = getContentType(filePath);
+    final filename = basename(filePath);
+    final storageKey = _getStorageKey(key, filename);
+
+    await _client.putObject(storageKey, bytes, contentType);
+    return {'storageUri': 'r2://${_config.bucketName}/$storageKey'};
+  }
+
+  @override
+  Future<bool> exists(String storageUri) async {
+    final parsed = parseStorageUri(storageUri, 'r2');
+    _ensureExpectedBucket(parsed.bucket, _config.bucketName);
+    return _client.headObject(parsed.key);
+  }
+
+  @override
+  Future<void> delete(String storageUri) async {
+    final parsed = parseStorageUri(storageUri, 'r2');
+    _ensureExpectedBucket(parsed.bucket, _config.bucketName);
+    await _client.deleteObject(parsed.key);
+  }
+
+  @override
+  Future<void> downloadFile(String storageUri, String filePath) async {
+    final parsed = parseStorageUri(storageUri, 'r2');
+    _ensureExpectedBucket(parsed.bucket, _config.bucketName);
+    final bytes = await _client.getObjectAsBytes(parsed.key);
+    await writeFileBytes(filePath, bytes);
+  }
+
+  @override
+  Future<List<StorageObject>> listObjects([String? prefix]) =>
+      _client.listObjects(prefix);
+
+  @override
+  Future<void> deleteObjects(List<String> keys) =>
+      _client.deleteObjects(keys);
+}
+
+class _R2RuntimeProfile implements RuntimeStorageProfile {
+  _R2RuntimeProfile(this._client, this._config);
+
+  final R2S3ClientLike _client;
+  final R2S3StorageConfig _config;
+
+  @override
+  Future<Map<String, String>> getDownloadUrl(String storageUri) async {
+    final parsed = parseStorageUri(storageUri, 'r2');
+    _ensureExpectedBucket(parsed.bucket, _config.bucketName);
+    final fileUrl = await _client.getSignedUrl(parsed.key);
+    return {'fileUrl': fileUrl};
+  }
+
+  @override
+  Future<String?> readText(String storageUri) async {
+    final parsed = parseStorageUri(storageUri, 'r2');
+    _ensureExpectedBucket(parsed.bucket, _config.bucketName);
+    try {
+      return await _client.getObjectAsString(parsed.key);
+    } catch (_) {
+      return null;
+    }
+  }
+}

package/dart-src/plugins/cloudflare/migrations/0001_hot-updater_init.sql

@@ -0,0 +1,16 @@
+-- Migration number: 0001 	 2025-01-27T08:37:50.374Z
+-- HotUpdater.bundles
+
+CREATE TABLE bundles (
+    id TEXT PRIMARY KEY,
+    platform TEXT NOT NULL CHECK (platform IN ('ios', 'android')),
+    target_app_version TEXT NOT NULL,
+    should_force_update INTEGER NOT NULL CHECK (should_force_update IN (0, 1)),
+    enabled INTEGER NOT NULL CHECK (enabled IN (0, 1)),
+    file_url TEXT NOT NULL,
+    file_hash TEXT NOT NULL,
+    git_commit_hash TEXT,
+    message TEXT
+);
+
+CREATE INDEX bundles_target_app_version_idx ON bundles(target_app_version);

package/dart-src/plugins/cloudflare/migrations/0002_hot-updater_0.13.0.sql

@@ -0,0 +1,8 @@
+-- Migration number: 0002 	 2025-03-07T16:25:12.486Z
+-- HotUpdater.bundles
+
+ALTER TABLE bundles
+ADD COLUMN channel TEXT NOT NULL DEFAULT 'production';
+
+ALTER TABLE bundles
+DROP COLUMN file_url;

package/dart-src/plugins/cloudflare/migrations/0003_hot-updater_0.18.0.sql

@@ -0,0 +1,38 @@
+-- Migration number: 0003 	 2025-05-18T16:25:12.486Z
+-- HotUpdater.bundles
+
+ALTER TABLE bundles ADD COLUMN fingerprint_hash TEXT;
+ALTER TABLE bundles ADD COLUMN storage_uri TEXT;
+ALTER TABLE bundles ADD COLUMN metadata JSONB DEFAULT '{}';
+
+UPDATE bundles
+SET storage_uri = 'r2://%%BUCKET_NAME%%/' || id || '/bundle.zip'
+WHERE storage_uri IS NULL;
+
+CREATE TABLE bundles_temp (
+    id TEXT PRIMARY KEY,
+    platform TEXT NOT NULL,
+    should_force_update INTEGER NOT NULL,
+    enabled INTEGER NOT NULL,
+    file_hash TEXT NOT NULL,
+    git_commit_hash TEXT,
+    message TEXT,
+    channel TEXT NOT NULL DEFAULT 'production',
+    storage_uri TEXT NOT NULL,
+    target_app_version TEXT,
+    fingerprint_hash TEXT,
+    metadata JSONB DEFAULT '{}',
+    CHECK ((target_app_version IS NOT NULL) OR (fingerprint_hash IS NOT NULL))
+);
+
+INSERT INTO bundles_temp 
+SELECT id, platform, should_force_update, enabled, file_hash, git_commit_hash, message, channel, storage_uri, target_app_version, fingerprint_hash, metadata
+FROM bundles;
+
+DROP TABLE bundles;
+
+ALTER TABLE bundles_temp RENAME TO bundles;
+
+CREATE INDEX bundles_target_app_version_idx ON bundles(target_app_version);
+CREATE INDEX bundles_fingerprint_hash_idx ON bundles(fingerprint_hash);
+CREATE INDEX bundles_channel_idx ON bundles(channel);

package/dart-src/plugins/cloudflare/migrations/0004_hot-updater_0.29.0.sql

@@ -0,0 +1,11 @@
+-- Migration number: 0004 	 2025-12-21T00:00:00.000Z
+
+-- HotUpdater.bundles
+
+ALTER TABLE bundles ADD COLUMN rollout_cohort_count INTEGER DEFAULT 1000
+  CHECK (rollout_cohort_count >= 0 AND rollout_cohort_count <= 1000);
+
+CREATE INDEX IF NOT EXISTS bundles_rollout_idx ON bundles(rollout_cohort_count);
+
+-- SQLite doesn't have array type, store as JSON text
+ALTER TABLE bundles ADD COLUMN target_cohorts TEXT;

package/dart-src/plugins/cloudflare/migrations/0005_hot-updater_0.31.0.sql

@@ -0,0 +1,24 @@
+-- Migration number: 0005 	 2026-04-22T00:00:00.000Z
+
+-- HotUpdater.bundle_artifact_columns
+
+ALTER TABLE bundles ADD COLUMN manifest_storage_uri TEXT;
+ALTER TABLE bundles ADD COLUMN manifest_file_hash TEXT;
+ALTER TABLE bundles ADD COLUMN asset_base_storage_uri TEXT;
+
+CREATE TABLE bundle_patches (
+    id TEXT PRIMARY KEY,
+    bundle_id TEXT NOT NULL,
+    base_bundle_id TEXT NOT NULL,
+    base_file_hash TEXT NOT NULL,
+    patch_file_hash TEXT NOT NULL,
+    patch_storage_uri TEXT NOT NULL,
+    order_index INTEGER NOT NULL DEFAULT 0,
+    FOREIGN KEY (bundle_id) REFERENCES bundles(id) ON DELETE CASCADE,
+    FOREIGN KEY (base_bundle_id) REFERENCES bundles(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS bundle_patches_bundle_id_idx
+    ON bundle_patches(bundle_id);
+CREATE INDEX IF NOT EXISTS bundle_patches_base_bundle_id_idx
+    ON bundle_patches(base_bundle_id);