@_nazmiforreal/flutter-ota 0.1.0 → 0.1.2

package/bin/flutter-patcher.js

@@ -3,57 +3,66 @@
 
 // Launcher for the flutter_patcher CLI.
 //
-// Resolves the prebuilt Dart binary shipped next to this script (platform
-// specific), falling back to `dart run` when Dart is available and no binary
-// is present. This lets `npm i -g flutter-patcher` work on any machine that
-// either ships a prebuilt binary or has the Dart SDK installed.
+// Resolves a platform+arch-specific prebuilt binary (`flutter-patcher-<os>-<arch>`)
+// shipped next to this script, falling back to `dart run` of the bundled Dart
+// source when no prebuilt exists for the current architecture (e.g. a user on
+// arm64 with only an x64 binary present). This keeps the package installable on
+// any platform that has the Dart SDK, without us needing to ship every binary.
 
 const { spawnSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 
-const platform =
-  process.platform === 'win32'
-    ? 'windows'
-    : process.platform === 'darwin'
-    ? 'macos'
-    : 'linux';
+function platform() {
+  if (process.platform === 'win32') return 'windows';
+  if (process.platform === 'darwin') return 'macos';
+  return 'linux';
+}
+
+function arch() {
+  // Only x64/arm64 matter for Dart AOT; everything else falls back to Dart VM.
+  return process.arch === 'arm64' ? 'arm64' : 'x64';
+}
+
+const platformName = platform();
+const archName = arch();
 const ext = process.platform === 'win32' ? '.exe' : '';
 const binDir = __dirname;
-const binName = `flutter-patcher-${platform}${ext}`;
+const binName = `flutter-patcher-${platformName}-${archName}${ext}`;
 const binPath = path.join(binDir, binName);
 
-function run(bin, args) {
-  const res = spawnSync(bin, args, { stdio: 'inherit', windowsHide: false });
+const sourceEntry = path.join(
+  binDir, '..', 'dart-src', 'packages', 'cli-tools', 'bin', 'flutter_patcher.dart',
+);
+
+function run(bin, args, cwd) {
+  const res = spawnSync(bin, args, { stdio: 'inherit', windowsHide: false, cwd });
   process.exit(res.status == null ? 1 : res.status);
 }
 
 if (fs.existsSync(binPath)) {
   run(binPath, process.argv.slice(2));
-  return;
+} else if (
+  spawnSync('dart', ['--version'], { stdio: 'ignore' }).status === 0 &&
+  fs.existsSync(sourceEntry)
+) {
+  // Ensure dependencies are resolved before running from source.
+  const cliDir = path.dirname(path.dirname(sourceEntry));
+  const getRes = spawnSync('dart', ['pub', 'get'], { stdio: 'inherit', cwd: cliDir });
+  if (getRes.status !== 0) {
+    console.error(
+      'flutter-patcher: `dart pub get` failed. Install dependencies or build ' +
+        `a prebuilt manually:\n  cd ${cliDir} && dart compile exe ` +
+        `bin/flutter_patcher.dart -o ${binPath}`,
+    );
+    process.exit(1);
+  }
+  run('dart', [sourceEntry, ...process.argv.slice(2)]);
+} else {
+  console.error(
+    `flutter-patcher: no prebuilt binary for ${platformName}-${archName} and ` +
+      'the Dart SDK was not found. Install Dart (https://dart.dev) or use a ' +
+      'platform/arch with a shipped prebuilt binary.',
+  );
+  process.exit(1);
 }
-
-// Fallback: run from source via the Dart SDK (works when this npm package is
-// installed from the monorepo, since the Dart package lives at
-// ../../packages/cli-tools/bin/flutter_patcher.dart).
-const repoEntry = path.join(
-  binDir,
-  '..',
-  '..',
-  '..',
-  'packages',
-  'cli-tools',
-  'bin',
-  'flutter-patcher.dart',
-);
-const dartCheck = spawnSync('dart', ['--version'], { stdio: 'ignore' });
-if (dartCheck.status === 0 && fs.existsSync(repoEntry)) {
-  run('dart', [repoEntry, ...process.argv.slice(2)]);
-  return;
-}
-
-console.error(
-  'flutter-patcher: no prebuilt binary for this platform and Dart SDK not ' +
-    'found. Install Dart (https://dart.dev) or ship a prebuilt binary.',
-);
-process.exit(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');
+      });
+}