@_nazmiforreal/flutter-ota 0.1.0 → 0.1.1

package/dart-src/packages/cli-tools/bin/flutter_patcher.dart

@@ -0,0 +1,9 @@
+import 'dart:io';
+
+import 'package:flutter_patcher_cli/flutter_patcher_cli.dart';
+
+/// `flutter_patcher` executable entry point.
+Future<void> main(List<String> args) async {
+  final code = await run(args);
+  if (code != 0) exitCode = code;
+}

package/dart-src/packages/cli-tools/lib/flutter_patcher_cli.dart

@@ -0,0 +1,73 @@
+/// flutter_patcher_cli — command-line interface for flutter_patcher.
+///
+/// Faithful Dart port of hot-updater's `@hot-updater/cli`: deploy bundles,
+/// manage channels/rollbacks, run migrations, and inspect the backend.
+library;
+
+import 'dart:io';
+
+import 'package:args/command_runner.dart';
+
+export 'src/backend.dart';
+export 'src/cli_base.dart';
+export 'src/config.dart';
+export 'src/operations.dart';
+export 'src/pack.dart';
+export 'src/sign.dart';
+export 'src/util.dart';
+
+export 'src/commands/init.dart';
+export 'src/commands/config_command.dart';
+export 'src/commands/keys.dart';
+export 'src/commands/doctor.dart';
+export 'src/commands/fingerprint.dart';
+export 'src/commands/deploy.dart';
+export 'src/commands/bundle.dart';
+export 'src/commands/build.dart';
+export 'src/commands/rollback.dart';
+export 'src/commands/channel.dart';
+export 'src/commands/migrate.dart';
+export 'src/commands/console.dart';
+
+import 'src/commands/build.dart';
+import 'src/commands/bundle.dart';
+import 'src/commands/channel.dart';
+import 'src/commands/config_command.dart';
+import 'src/commands/console.dart';
+import 'src/commands/deploy.dart';
+import 'src/commands/doctor.dart';
+import 'src/commands/fingerprint.dart';
+import 'src/commands/init.dart';
+import 'src/commands/keys.dart';
+import 'src/commands/migrate.dart';
+import 'src/commands/rollback.dart';
+
+/// Entry point: build the command runner and dispatch [args].
+Future<int> run(List<String> args) async {
+  final runner = CommandRunner<int>(
+    'flutter_patcher',
+    'flutter_patcher CLI — OTA code push for Flutter (hot-updater compatible).',
+  )
+    ..addCommand(InitCommand())
+    ..addCommand(ConfigCommand())
+    ..addCommand(KeysCommand())
+    ..addCommand(DoctorCommand())
+    ..addCommand(FingerprintCommand())
+    ..addCommand(DeployCommand())
+    ..addCommand(BuildCommand())
+    ..addCommand(BundleCommand())
+    ..addCommand(RollbackCommand())
+    ..addCommand(ChannelCommand())
+    ..addCommand(MigrateCommand())
+    ..addCommand(ConsoleCommand());
+
+  try {
+    final result = await runner.run(args);
+    return result ?? 0;
+  } on UsageException catch (e) {
+    stderr.writeln(e.message);
+    stderr.writeln('');
+    stderr.writeln(e.usage);
+    return 64;
+  }
+}

package/dart-src/packages/cli-tools/lib/src/backend.dart

@@ -0,0 +1,162 @@
+import 'package:flutter_patcher_aws/flutter_patcher_aws.dart';
+import 'package:flutter_patcher_cloudflare/flutter_patcher_cloudflare.dart';
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart';
+import 'package:flutter_patcher_postgres/flutter_patcher_postgres.dart';
+import 'package:flutter_patcher_standalone/flutter_patcher_standalone.dart';
+import 'package:flutter_patcher_supabase/flutter_patcher_supabase.dart';
+
+import 'config.dart';
+
+/// Backend handle wiring the database + node storage profiles used by the CLI.
+class Backend {
+  const Backend({
+    required this.db,
+    required this.storage,
+    this.basePath,
+  });
+
+  final DatabasePlugin db;
+  final NodeStorageProfile storage;
+
+  /// Optional storage key prefix (e.g. "bundles") honored when building keys.
+  final String? basePath;
+
+  /// Build the storage object key for a bundle artifact.
+  String storageKeyFor(String bundleId, String file) {
+    final parts = [
+      if (basePath != null && basePath!.isNotEmpty) basePath!,
+      bundleId,
+      file,
+    ];
+    return parts.join('/');
+  }
+}
+
+/// Construct a [Backend] for the configured provider.
+///
+/// Supports `supabase`, `postgres`, `cloudflare`, and `aws`. Credential
+/// precedence is: explicit factory/flag > environment variable > JSON config
+/// (see the `resolve*Config` helpers in `config.dart`). Test seams let callers
+/// inject mock clients (e.g. `postgresClientFactory`).
+Backend resolveBackend(
+  FlutterPatcherConfig config, {
+  SupabaseClientFactory? supabaseClientFactory,
+  D1ClientFactory? d1ClientFactory,
+  R2S3ClientFactory? r2ClientFactory,
+  PostgresClientFactory? postgresClientFactory,
+  AwsS3ClientLike Function(S3DatabaseConfig config)? awsS3ClientFactory,
+  AwsCloudFrontClientLike Function(S3DatabaseConfig config)?
+      awsCloudFrontClientFactory,
+  AwsS3ClientLike Function(AwsS3StorageConfig config)? awsStorageClientFactory,
+  StandaloneClientFactory? standaloneClientFactory,
+}) {
+  switch (config.provider) {
+    case 'supabase':
+      final dbConfig = resolveSupabaseConfig(
+        config,
+        clientFactory: supabaseClientFactory,
+      );
+      final storageConfig = resolveSupabaseStorageConfig(
+        config,
+        clientFactory: supabaseClientFactory,
+      );
+      final db = supabaseDatabase(dbConfig)();
+      final storage = supabaseStorage(storageConfig);
+      final node = storage.profiles.node;
+      if (node == null) {
+        throw StateError('Supabase storage plugin exposes no node profile.');
+      }
+      return Backend(
+        db: db,
+        storage: node,
+        basePath: storageConfig.basePath,
+      );
+
+    case 'postgres':
+      final dbConfig = resolvePostgresDatabaseConfig(
+        config,
+        clientFactory: postgresClientFactory,
+      );
+      final storageConfig = resolvePostgresStorageConfig(
+        config,
+        clientFactory: postgresClientFactory,
+      );
+      final db = postgresDatabase(dbConfig)();
+      final storage = postgresStorage(storageConfig);
+      final node = storage.profiles.node;
+      if (node == null) {
+        throw StateError('Postgres storage plugin exposes no node profile.');
+      }
+      return Backend(
+        db: db,
+        storage: node,
+        basePath: storageConfig.basePath,
+      );
+
+    case 'cloudflare':
+      final dbConfig = resolveCloudflareDatabaseConfig(
+        config,
+        clientFactory: d1ClientFactory,
+      );
+      final storageConfig = resolveCloudflareStorageConfig(
+        config,
+        clientFactory: r2ClientFactory,
+      );
+      final db = d1Database(dbConfig)();
+      final storage = r2Storage(storageConfig);
+      final node = storage.profiles.node;
+      if (node == null) {
+        throw StateError('R2 storage plugin exposes no node profile.');
+      }
+      return Backend(
+        db: db,
+        storage: node,
+        basePath: storageConfig.basePath,
+      );
+
+    case 'aws':
+      final dbConfig = resolveAwsDatabaseConfig(
+        config,
+        clientFactory: awsS3ClientFactory,
+        cloudfrontClientFactory: awsCloudFrontClientFactory,
+      );
+      final storageConfig = resolveAwsStorageConfig(
+        config,
+        clientFactory: awsStorageClientFactory,
+      );
+      final db = s3Database(dbConfig)();
+      final storage = s3Storage(storageConfig);
+      final node = storage.profiles.node;
+      if (node == null) {
+        throw StateError('S3 storage plugin exposes no node profile.');
+      }
+      return Backend(
+        db: db,
+        storage: node,
+        basePath: storageConfig.basePath,
+      );
+
+    case 'standalone':
+      final dbConfig = resolveStandaloneDatabaseConfig(
+        config,
+        clientFactory: standaloneClientFactory,
+      );
+      final storageConfig = resolveStandaloneStorageConfig(
+        config,
+        clientFactory: standaloneClientFactory,
+      );
+      final db = standaloneRepository(dbConfig)();
+      final storage = standaloneStorage(storageConfig);
+      final node = storage.profiles.node;
+      if (node == null) {
+        throw StateError('Standalone storage plugin exposes no node profile.');
+      }
+      return Backend(db: db, storage: node);
+
+    default:
+      throw UnsupportedError(
+        'Provider "${config.provider}" is not supported. '
+        'Supported: supabase, postgres, cloudflare, aws, standalone.',
+      );
+  }
+}

package/dart-src/packages/cli-tools/lib/src/cli_base.dart

@@ -0,0 +1,56 @@
+import 'dart:io';
+
+import 'package:args/args.dart';
+
+import 'backend.dart';
+import 'config.dart';
+
+/// Run [body], mapping errors to a non-zero exit code with a clean message.
+
+/// Run [body], mapping errors to a non-zero exit code with a clean message.
+Future<int> runGuarded(Future<void> Function() body) async {
+  try {
+    await body();
+    return 0;
+  } on StateError catch (e) {
+    stderr.writeln('error: ${e.message}');
+    return 1;
+  } catch (e) {
+    stderr.writeln('error: $e');
+    return 1;
+  }
+}
+
+/// Resolve a [Backend] from config, or return the injected override (tests).
+Backend requireBackend(FlutterPatcherConfig? config, {Backend? override}) {
+  if (override != null) return override;
+  if (config == null) {
+    throw StateError(
+      'No configuration found. Run `flutter_patcher init` or set '
+      'SUPABASE_URL / SUPABASE_SERVICE_ROLE_KEY.',
+    );
+  }
+  return resolveBackend(config);
+}
+
+/// Apply a `--backend` flag override to the loaded config.
+///
+/// Returns `cfg` unchanged when no `--backend` flag is present. When the flag
+/// is set but no config exists yet, a minimal config with that provider is
+/// created (so env-driven credentials still resolve).
+FlutterPatcherConfig? effectiveConfig(
+  FlutterPatcherConfig? cfg,
+  ArgResults argResults,
+) {
+  final backend = argResults['backend'] as String?;
+  if (backend == null) return cfg;
+  final base = cfg ??
+      FlutterPatcherConfig(
+        provider: backend,
+        supabase: const SupabaseConfigJson(),
+        postgres: const PostgresConfigJson(),
+        cloudflare: const CloudflareConfigJson(),
+        aws: const AwsConfigJson(),
+      );
+  return base.copyWith(provider: backend);
+}

package/dart-src/packages/cli-tools/lib/src/commands/build.dart

@@ -0,0 +1,99 @@
+import 'dart:io';
+
+import 'package:args/command_runner.dart';
+import 'package:flutter_patcher_cli/flutter_patcher_cli.dart';
+
+/// `flutter_patcher build` — package a release APK into a device-compatible
+/// OTA patch (`dist/patch.zip`) that the `deploy` command can publish.
+///
+/// Includes every ABI found in the APK so a single bundle installs on all
+/// device architectures.
+class BuildCommand extends Command<int> {
+  BuildCommand() {
+    argParser
+      ..addOption(
+        'apk',
+        abbr: 'a',
+        help: 'Path to the release APK to extract libapp.so and assets from.',
+      )
+      ..addMultiOption(
+        'assets',
+        help: 'Asset keys to include as overlay updates (repeatable).',
+      )
+      ..addOption(
+        'version',
+        help: 'Patch version string (stored in manifest.version).',
+      )
+      ..addOption(
+        'target-version-code',
+        help: 'Host APK versionCode this patch targets (integer).',
+      )
+      ..addOption(
+        'abi',
+        help: 'Preferred ABI to report (default: all ABIs found in APK).',
+      )
+      ..addOption(
+        'out',
+        abbr: 'o',
+        defaultsTo: 'dist',
+        help: 'Output directory for patch.zip and manifest.json.',
+      );
+  }
+
+  @override
+  String get name => 'build';
+
+  @override
+  String get description =>
+      'Build a device-compatible OTA patch (patch.zip) from a release APK.';
+
+  @override
+  Future<int> run() async {
+    final results = argResults!;
+    final apk = results['apk'] as String?;
+    if (apk == null || apk.isEmpty) {
+      stderr.writeln('error: missing required --apk <path>');
+      return 64;
+    }
+    final version = results['version'] as String?;
+    if (version == null || version.isEmpty) {
+      stderr.writeln('error: missing required --version <string>');
+      return 64;
+    }
+    final targetVersionCodeRaw = results['target-version-code'] as String?;
+    if (targetVersionCodeRaw == null || targetVersionCodeRaw.isEmpty) {
+      stderr.writeln('error: missing required --target-version-code <int>');
+      return 64;
+    }
+    final targetVersionCode = int.tryParse(targetVersionCodeRaw);
+    if (targetVersionCode == null) {
+      stderr.writeln('error: --target-version-code must be an integer');
+      return 64;
+    }
+
+    try {
+      final result = await packPatch(
+        apkPath: apk,
+        version: version,
+        targetVersionCode: targetVersionCode,
+        abi: results['abi'] as String?,
+        requestedAssets: results['assets'] as List<String>,
+        out: results['out'] as String,
+      );
+      stdout.writeln('[build] version: ${result.version}');
+      stdout.writeln('[build] targetVersionCode: ${result.targetVersionCode}');
+      stdout.writeln('[build] abis: ${result.abis.join(', ')}');
+      stdout.writeln('[build] bundle md5: ${result.md5}');
+      stdout.writeln('[build] overlay assets: ${result.assetCount}');
+      stdout.writeln('[build] payload: ${result.payloadPath}');
+      stdout.writeln('[build] manifest: ${result.manifestPath}');
+      return 0;
+    } on PackException catch (e) {
+      stderr.writeln('error: ${e.message}');
+      return e.exitCode;
+    } on Object catch (e) {
+      stderr.writeln('error: $e');
+      return 1;
+    }
+  }
+}

package/dart-src/packages/cli-tools/lib/src/commands/bundle.dart

@@ -0,0 +1,151 @@
+import 'dart:io';
+
+import 'package:args/args.dart';
+import 'package:args/command_runner.dart';
+
+import '../backend.dart';
+import '../cli_base.dart';
+import '../config.dart';
+import '../operations.dart';
+
+/// `flutter_patcher bundle` — manage bundles.
+class BundleCommand extends Command<int> {
+  BundleCommand({this.config, this.backendOverride});
+
+  final FlutterPatcherConfig? config;
+  final Backend? backendOverride;
+
+  @override
+  String get name => 'bundle';
+
+  @override
+  String get description => 'Manage bundles (list / delete / promote).';
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        print(description);
+        print('');
+        print('Subcommands:');
+        print('  list                List bundles');
+        print('  delete <id>         Delete a bundle');
+        print('  promote <id> -c <c> Promote a bundle to a channel');
+      });
+}
+
+class BundleListCommand extends Command<int> {
+  BundleListCommand({this.config, this.backendOverride});
+
+  final FlutterPatcherConfig? config;
+  final Backend? backendOverride;
+
+  @override
+  String get name => 'list';
+
+  @override
+  String get description => 'List bundles.';
+
+  @override
+  ArgParser get argParser => ArgParser()
+    ..addOption('backend', abbr: 'b', help: 'Backend provider.')
+    ..addOption('channel', abbr: 'c', help: 'Filter by channel.')
+    ..addOption('platform', abbr: 'p', help: 'Filter by platform.')
+    ..addOption('enabled', help: 'Filter by enabled (true/false).')
+    ..addOption('limit', abbr: 'l', defaultsTo: '20', help: 'Page size.');
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        final cfg = effectiveConfig(config ?? loadConfig(), argResults!);
+        final backend = requireBackend(cfg, override: backendOverride);
+        final enabledRaw = argResults!['enabled'] as String?;
+        final enabled = enabledRaw == null
+            ? null
+            : (enabledRaw == 'true' || enabledRaw == '1');
+        final res = await listBundles(
+          backend,
+          ListOptions(
+            channel: argResults!['channel'] as String?,
+            platform: argResults!['platform'] as String?,
+            enabled: enabled,
+            limit: int.parse(argResults!['limit'] as String),
+          ),
+        );
+        if (res.data.isEmpty) {
+          stdout.writeln('(no bundles)');
+          return;
+        }
+        stdout.writeln('id                                   channel      '
+            'enabled platform target');
+        for (final b in res.data) {
+          final target = b.targetAppVersion ?? b.fingerprintHash ?? '-';
+          stdout.writeln('${b.id}  ${b.channel.padRight(12)}  '
+              '${(b.enabled ? 'yes' : 'no').padRight(7)} '
+              '${b.platform.value.padRight(7)} $target');
+        }
+        stdout.writeln('');
+        stdout.writeln('total: ${res.pagination.total}');
+      });
+}
+
+class BundleDeleteCommand extends Command<int> {
+  BundleDeleteCommand({this.config, this.backendOverride});
+
+  final FlutterPatcherConfig? config;
+  final Backend? backendOverride;
+
+  @override
+  String get name => 'delete';
+
+  @override
+  String get description => 'Delete a bundle by id.';
+
+  @override
+  ArgParser get argParser => ArgParser()
+    ..addOption('backend', abbr: 'b', help: 'Backend provider.')
+    ..addOption('id', help: 'Bundle id.');
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        final id = argResults!['id'] as String?;
+        if (id == null || id.isEmpty) {
+          throw StateError('Usage: flutter_patcher bundle delete <id>');
+        }
+        final cfg = effectiveConfig(config ?? loadConfig(), argResults!);
+        final backend = requireBackend(cfg, override: backendOverride);
+        await deleteBundle(backend, id);
+        stdout.writeln('Deleted bundle $id');
+      });
+}
+
+class BundlePromoteCommand extends Command<int> {
+  BundlePromoteCommand({this.config, this.backendOverride});
+
+  final FlutterPatcherConfig? config;
+  final Backend? backendOverride;
+
+  @override
+  String get name => 'promote';
+
+  @override
+  String get description => 'Promote a bundle to a channel.';
+
+  @override
+  ArgParser get argParser => ArgParser()
+    ..addOption('backend', abbr: 'b', help: 'Backend provider.')
+    ..addOption('id', help: 'Bundle id.')
+    ..addOption('channel', abbr: 'c', help: 'Target channel.');
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        final id = argResults!['id'] as String?;
+        final channel = argResults!['channel'] as String?;
+        if (id == null || id.isEmpty || channel == null || channel.isEmpty) {
+          throw StateError(
+            'Usage: flutter_patcher bundle promote <id> --channel <channel>',
+          );
+        }
+        final cfg = effectiveConfig(config ?? loadConfig(), argResults!);
+        final backend = requireBackend(cfg, override: backendOverride);
+        await promoteBundle(backend, id, channel);
+        stdout.writeln('Promoted bundle $id to channel $channel');
+      });
+}

package/dart-src/packages/cli-tools/lib/src/commands/channel.dart

@@ -0,0 +1,140 @@
+import 'dart:io';
+
+import 'package:args/args.dart';
+import 'package:args/command_runner.dart';
+
+import '../backend.dart';
+import '../cli_base.dart';
+import '../config.dart';
+import '../operations.dart';
+
+/// `flutter_patcher channel` — manage channels.
+class ChannelCommand extends Command<int> {
+  final FlutterPatcherConfig? config;
+  final Backend? backendOverride;
+
+  ChannelCommand({this.config, this.backendOverride}) {
+    addSubcommand(ChannelListCommand(config: config, backendOverride: backendOverride));
+    addSubcommand(ChannelGetCommand(config: config, backendOverride: backendOverride));
+    addSubcommand(ChannelSetCommand(config: config, backendOverride: backendOverride));
+  }
+
+  @override
+  String get name => 'channel';
+
+  @override
+  String get description => 'Manage channels (list / get / set).';
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        print(description);
+        print('');
+        print('Subcommands:');
+        print('  list              List channels');
+        print('  get <channel>     Show the live bundle for a channel');
+        print('  set <c> <id>      Promote a bundle to a channel');
+      });
+}
+
+class ChannelListCommand extends Command<int> {
+  ChannelListCommand({this.config, this.backendOverride});
+
+  final FlutterPatcherConfig? config;
+  final Backend? backendOverride;
+
+  @override
+  String get name => 'list';
+
+  @override
+  String get description => 'List channels.';
+
+  @override
+  ArgParser get argParser => ArgParser()
+    ..addOption('backend', abbr: 'b', help: 'Backend provider.');
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        final cfg = effectiveConfig(config ?? loadConfig(), argResults!);
+        final backend = requireBackend(cfg, override: backendOverride);
+        final channels = await listChannels(backend);
+        if (channels.isEmpty) {
+          stdout.writeln('(no channels)');
+          return;
+        }
+        for (final c in channels) {
+          stdout.writeln('  $c');
+        }
+      });
+}
+
+class ChannelGetCommand extends Command<int> {
+  ChannelGetCommand({this.config, this.backendOverride});
+
+  final FlutterPatcherConfig? config;
+  final Backend? backendOverride;
+
+  @override
+  String get name => 'get';
+
+  @override
+  String get description => 'Show the live (enabled) bundle for a channel.';
+
+  @override
+  ArgParser get argParser => ArgParser()
+    ..addOption('backend', abbr: 'b', help: 'Backend provider.')
+    ..addOption('channel', help: 'Channel.');
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        final channel = argResults!['channel'] as String?;
+        if (channel == null || channel.isEmpty) {
+          throw StateError('Usage: flutter_patcher channel get <channel>');
+        }
+        final cfg = effectiveConfig(config ?? loadConfig(), argResults!);
+        final backend = requireBackend(cfg, override: backendOverride);
+        final bundle = await getChannel(backend, channel);
+        if (bundle == null) {
+          stdout.writeln('(no live bundle on channel "$channel")');
+          return;
+        }
+        stdout.writeln('channel "$channel" -> bundle ${bundle.id} '
+            '(${bundle.platform.value})');
+      });
+}
+
+class ChannelSetCommand extends Command<int> {
+  ChannelSetCommand({this.config, this.backendOverride});
+
+  final FlutterPatcherConfig? config;
+  final Backend? backendOverride;
+
+  @override
+  String get name => 'set';
+
+  @override
+  String get description => 'Promote a bundle to a channel.';
+
+  @override
+  ArgParser get argParser => ArgParser()
+    ..addOption('backend', abbr: 'b', help: 'Backend provider.')
+    ..addOption('channel', help: 'Channel.')
+    ..addOption('bundle-id', help: 'Bundle id.');
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        final channel = argResults!['channel'] as String?;
+        final bundleId = argResults!['bundle-id'] as String?;
+        if (channel == null ||
+            channel.isEmpty ||
+            bundleId == null ||
+            bundleId.isEmpty) {
+          throw StateError(
+            'Usage: flutter_patcher channel set --channel <c> --bundle-id <id>',
+          );
+        }
+        final cfg = effectiveConfig(config ?? loadConfig(), argResults!);
+        final backend = requireBackend(cfg, override: backendOverride);
+        await promoteBundle(backend, bundleId, channel);
+        stdout.writeln('Channel "$channel" -> bundle $bundleId');
+      });
+}