@_nazmiforreal/flutter-ota 0.1.0 → 0.1.2

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');
+      });
+}

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

@@ -0,0 +1,113 @@
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:args/args.dart';
+import 'package:args/command_runner.dart';
+
+import '../cli_base.dart';
+import '../config.dart';
+
+/// `flutter_patcher config` — get/set/list config values.
+class ConfigCommand extends Command<int> {
+  ConfigCommand() {
+    addSubcommand(ConfigGetCommand());
+    addSubcommand(ConfigSetCommand());
+    addSubcommand(ConfigListCommand());
+  }
+
+  @override
+  String get name => 'config';
+
+  @override
+  String get description => 'Get, set, or list configuration values.';
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        // No subcommand selected.
+        print(description);
+        print(''); print('Subcommands:'); print('  get <key>'); print('  set <key> <value>'); print('  list');
+      });
+}
+
+Map<String, dynamic> _loadProjectJson() {
+  final file = configCandidates().first;
+  if (!file.existsSync()) return <String, dynamic>{};
+  final raw = file.readAsStringSync();
+  if (raw.trim().isEmpty) return <String, dynamic>{};
+  return jsonDecode(raw) as Map<String, dynamic>;
+}
+
+void _saveProjectJson(Map<String, dynamic> json) {
+  final file = configCandidates().first;
+  file.parent.createSync(recursive: true);
+  file.writeAsStringSync(
+    const JsonEncoder.withIndent('  ').convert(json),
+  );
+}
+
+class ConfigGetCommand extends Command<int> {
+  @override
+  String get name => 'get';
+
+  @override
+  String get description => 'Print a config value by dot-path (e.g. supabase.url).';
+
+  @override
+  ArgParser get argParser => ArgParser()..addOption('key', help: 'Dot-path key.');
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        final key = argResults!['key'] as String?;
+        if (key == null || key.isEmpty) {
+          throw StateError('Usage: flutter_patcher config get <key>');
+        }
+        final value = readPath(_loadProjectJson(), key);
+        if (value == null) {
+          stderr.writeln('(not set)');
+          return;
+        }
+        stdout.writeln(
+          value is String ? value : const JsonEncoder().convert(value),
+        );
+      });
+}
+
+class ConfigSetCommand extends Command<int> {
+  @override
+  String get name => 'set';
+
+  @override
+  String get description => 'Set a config value by dot-path.';
+
+  @override
+  ArgParser get argParser => ArgParser()
+    ..addOption('key', help: 'Dot-path key.')
+    ..addOption('value', help: 'Value.');
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        final key = argResults!['key'] as String?;
+        final value = argResults!['value'] as String?;
+        if (key == null || key.isEmpty || value == null) {
+          throw StateError('Usage: flutter_patcher config set <key> <value>');
+        }
+        final json = _loadProjectJson();
+        writePath(json, key, value);
+        _saveProjectJson(json);
+        stdout.writeln('Set $key = $value');
+      });
+}
+
+class ConfigListCommand extends Command<int> {
+  @override
+  String get name => 'list';
+
+  @override
+  String get description => 'Print the full config.';
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        final json = _loadProjectJson();
+        stdout.writeln(const JsonEncoder.withIndent('  ').convert(json));
+      });
+}

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

@@ -0,0 +1,55 @@
+import 'dart:io';
+
+import 'package:args/args.dart';
+import 'package:args/command_runner.dart';
+import 'package:path/path.dart' as p;
+
+import '../cli_base.dart';
+
+/// `flutter_patcher console` — open the web console.
+class ConsoleCommand extends Command<int> {
+  @override
+  String get name => 'console';
+
+  @override
+  String get description => 'Open the flutter_patcher web console.';
+
+  @override
+  ArgParser get argParser => ArgParser()
+    ..addFlag('open',
+        help: 'Launch the console with `flutter run -d chrome` (requires Flutter).');
+
+  Directory? _findConsoleDir() {
+    var dir = Directory(p.dirname(Platform.script.path));
+    while (dir.path != dir.parent.path) {
+      final candidate = Directory(p.join(dir.path, 'packages', 'console'));
+      if (candidate.existsSync()) return candidate;
+      dir = dir.parent;
+    }
+    return null;
+  }
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        final consoleDir = _findConsoleDir();
+        if (consoleDir == null) {
+          stdout.writeln('Console package not found (expected packages/console).');
+          return;
+        }
+        if (argResults!['open'] as bool) {
+          stdout.writeln('Launching console...');
+          final process = await Process.start(
+            'flutter',
+            ['run', '-d', 'chrome'],
+            workingDirectory: consoleDir.path,
+            runInShell: true,
+            mode: ProcessStartMode.inheritStdio,
+          );
+          exitCode = await process.exitCode;
+          return;
+        }
+        stdout.writeln('flutter_patcher web console:');
+        stdout.writeln('  cd ${consoleDir.path}');
+        stdout.writeln('  flutter run -d chrome');
+      });
+}

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

@@ -0,0 +1,95 @@
+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';
+import '../util.dart';
+
+/// `flutter_patcher deploy` — zip + upload + register a new bundle.
+class DeployCommand extends Command<int> {
+  DeployCommand({this.config, this.backendOverride});
+
+  final FlutterPatcherConfig? config;
+  final Backend? backendOverride;
+
+  @override
+  String get name => 'deploy';
+
+  @override
+  String get description =>
+      'Zip a source directory, upload it, and register a new bundle.';
+
+  @override
+  ArgParser get argParser => ArgParser()
+    ..addOption('backend',
+        abbr: 'b', help: 'Backend provider (supabase/postgres/cloudflare/aws).')
+    ..addOption('source', abbr: 's', help: 'Source directory to zip + upload.')
+    ..addOption('channel', abbr: 'c', help: 'Target channel.')
+    ..addOption('platform', abbr: 'p', defaultsTo: 'android', help: 'Platform.')
+    ..addOption('message', abbr: 'm', help: 'Release message.')
+    ..addFlag('force', help: 'Force the update on clients.')
+    ..addOption('target-app-version',
+        help: 'Semver range target (XOR with fingerprint-hash).')
+    ..addOption('fingerprint-hash',
+        help: 'Fingerprint hash target (XOR with target-app-version).')
+    ..addOption('key', help: 'Path to Ed25519 private key file (sign bundle).')
+    ..addOption('git-commit-hash', help: 'Git commit hash (auto-detected).')
+    ..addOption('bundle-id', help: 'Explicit bundle id (uuidv7 by default).');
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        final cfg = effectiveConfig(config ?? loadConfig(), argResults!);
+        final backend = requireBackend(cfg, override: backendOverride);
+        final source = argResults!['source'] as String? ?? cfg?.source ?? './dist';
+        final channel =
+            argResults!['channel'] as String? ?? cfg?.channel ?? 'production';
+        final platform =
+            argResults!['platform'] as String? ?? cfg?.platform ?? 'android';
+        final message = argResults!['message'] as String?;
+        final force = argResults!['force'] as bool;
+        final targetAppVersion = argResults!['target-app-version'] as String?;
+        final fingerprintHash = argResults!['fingerprint-hash'] as String?;
+        final keyPath = argResults!['key'] as String?;
+        String? signingKey;
+        if (keyPath != null) signingKey = File(keyPath).readAsStringSync().trim();
+        final resolvedGitCommitHash =
+            argResults!['git-commit-hash'] as String? ?? await gitCommitHash(source);
+        final bundleId = argResults!['bundle-id'] as String?;
+
+        final bundle = await deployBundle(
+          backend,
+          DeployOptions(
+            source: source,
+            channel: channel,
+            platform: platform,
+            message: message,
+            force: force,
+            targetAppVersion: targetAppVersion,
+            fingerprintHash: fingerprintHash,
+            signingKeyBase64: signingKey,
+            gitCommitHash: resolvedGitCommitHash,
+            bundleId: bundleId,
+          ),
+        );
+
+        stdout.writeln('Deployed bundle ${bundle.id}');
+        stdout.writeln('  channel:    ${bundle.channel}');
+        stdout.writeln('  platform:   ${bundle.platform.value}');
+        stdout.writeln('  enabled:    ${bundle.enabled}');
+        stdout.writeln('  storageUri: ${bundle.storageUri}');
+        if (bundle.targetAppVersion != null) {
+          stdout.writeln('  targetAppVersion: ${bundle.targetAppVersion}');
+        }
+        if (bundle.fingerprintHash != null) {
+          stdout.writeln('  fingerprintHash: ${bundle.fingerprintHash}');
+        }
+        if (bundle.gitCommitHash != null) {
+          stdout.writeln('  gitCommitHash:   ${bundle.gitCommitHash}');
+        }
+        if (bundle.message != null) stdout.writeln('  message:    ${bundle.message}');
+      });
+}

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

@@ -0,0 +1,48 @@
+import 'dart:io';
+
+import 'package:args/args.dart';
+import 'package:args/command_runner.dart';
+
+import '../backend.dart';
+import '../cli_base.dart';
+import '../config.dart';
+
+/// `flutter_patcher doctor` — environment + backend connectivity check.
+class DoctorCommand extends Command<int> {
+  DoctorCommand({this.config, this.backendOverride});
+
+  final FlutterPatcherConfig? config;
+  final Backend? backendOverride;
+
+  @override
+  String get name => 'doctor';
+
+  @override
+  String get description => 'Diagnose the local environment and backend connection.';
+
+  @override
+  ArgParser get argParser => ArgParser()
+    ..addOption('backend', abbr: 'b', help: 'Backend provider.');
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        stdout.writeln('flutter_patcher CLI doctor');
+        stdout.writeln('  dart:   ${Platform.version.split(' ').first}');
+        stdout.writeln('  os:     ${Platform.operatingSystem} '
+            '${Platform.operatingSystemVersion.split('\n').first}');
+        final cfg = effectiveConfig(config ?? loadConfig(), argResults!);
+        if (cfg == null) {
+          stdout.writeln('  config: not found (run `flutter_patcher init`)');
+          return;
+        }
+        stdout.writeln('  config: provider=${cfg.provider} '
+            'channel=${cfg.channel} platform=${cfg.platform}');
+        try {
+          final backend = requireBackend(cfg, override: backendOverride);
+          final channels = await backend.db.getChannels();
+          stdout.writeln('  backend: reachable (channels: ${channels.join(', ')})');
+        } catch (e) {
+          stdout.writeln('  backend: unreachable — $e');
+        }
+      });
+}

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

@@ -0,0 +1,29 @@
+import 'dart:io';
+
+import 'package:args/args.dart';
+import 'package:args/command_runner.dart';
+
+import '../cli_base.dart';
+import '../util.dart';
+
+/// `flutter_patcher fingerprint` — compute a build-time fingerprint hash.
+class FingerprintCommand extends Command<int> {
+  @override
+  String get name => 'fingerprint';
+
+  @override
+  String get description =>
+      'Compute a deterministic fingerprint hash for a directory (build-time).';
+
+  @override
+  ArgParser get argParser => ArgParser()
+    ..addOption('source',
+        abbr: 's', defaultsTo: './dist', help: 'Directory to fingerprint.');
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        final source = argResults!['source'] as String;
+        final hash = generateFingerprint(source);
+        stdout.writeln(hash);
+      });
+}

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

@@ -0,0 +1,82 @@
+import 'dart:io';
+
+import 'package:args/args.dart';
+import 'package:args/command_runner.dart';
+
+import '../backend.dart';
+import '../cli_base.dart';
+import '../config.dart';
+
+/// `flutter_patcher init` — scaffold a project config file.
+class InitCommand extends Command<int> {
+  InitCommand({this.config, this.backendOverride});
+
+  final FlutterPatcherConfig? config;
+  final Backend? backendOverride;
+
+  @override
+  String get name => 'init';
+
+  @override
+  String get description =>
+      'Scaffold a .flutter_patcher.json config for the current project.';
+
+  @override
+  ArgParser get argParser => ArgParser()
+    ..addOption('provider', defaultsTo: 'supabase', help: 'Backend provider.')
+    ..addOption('url', help: 'Supabase project URL.')
+    ..addOption('key', help: 'Supabase service role key.')
+    ..addOption('anon-key', help: 'Supabase anon key.')
+    ..addOption('bucket', defaultsTo: 'bundles', help: 'Storage bucket.')
+    ..addOption('base-path', help: 'Storage base path.')
+    ..addOption('channel', defaultsTo: 'production', help: 'Default channel.')
+    ..addOption('platform', defaultsTo: 'android', help: 'Default platform.')
+    ..addOption('source', defaultsTo: './dist', help: 'Default deploy source.')
+    ..addFlag('force', abbr: 'f', help: 'Overwrite an existing config.');
+
+  String? _prompt(String label, String? current) {
+    if (!stdin.hasTerminal) return current;
+    stdout.write('$label${current != null ? ' [$current]' : ''}: ');
+    final line = stdin.readLineSync();
+    return (line == null || line.trim().isEmpty) ? current : line.trim();
+  }
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        final file = configCandidates().first;
+        if (file.existsSync() && !(argResults!['force'] as bool)) {
+          throw StateError(
+            'Config already exists at ${file.path}. Use --force to overwrite.',
+          );
+        }
+
+        final provider = argResults!['provider'] as String;
+        final url = _prompt('Supabase URL', argResults!['url'] as String?);
+        final key = _prompt(
+          'Supabase service role key',
+          argResults!['key'] as String?,
+        );
+        final anonKey = argResults!['anon-key'] as String?;
+        final bucket = argResults!['bucket'] as String? ?? 'bundles';
+        final basePath = argResults!['base-path'] as String?;
+        final channel = argResults!['channel'] as String? ?? 'production';
+        final platform = argResults!['platform'] as String? ?? 'android';
+        final source = argResults!['source'] as String? ?? './dist';
+
+        final cfg = FlutterPatcherConfig(
+          provider: provider,
+          supabase: SupabaseConfigJson(
+            url: url,
+            serviceRoleKey: key,
+            anonKey: anonKey,
+            bucket: bucket,
+            basePath: basePath,
+          ),
+          channel: channel,
+          platform: platform,
+          source: source,
+        );
+        saveConfig(cfg);
+        stdout.writeln('Wrote ${file.path}');
+      });
+}

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

@@ -0,0 +1,55 @@
+import 'dart:convert';
+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 '../sign.dart';
+
+/// `flutter_patcher keys` — generate an Ed25519 keypair for bundle signing.
+class KeysCommand extends Command<int> {
+  KeysCommand({this.config, this.backendOverride});
+
+  final FlutterPatcherConfig? config;
+  final Backend? backendOverride;
+
+  @override
+  String get name => 'keys';
+
+  @override
+  String get description =>
+      'Generate an Ed25519 keypair used to sign deployed bundles.';
+
+  @override
+  ArgParser get argParser => ArgParser()
+    ..addFlag('save', help: 'Persist the public key into the project config.');
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        final (privateB64, publicB64) = await generateEd25519KeyPair();
+        stdout.writeln('Private key (keep secret, use with `deploy --key`):');
+        stdout.writeln('  $privateB64');
+        stdout.writeln('');
+        stdout.writeln('Public key (safe to embed / configure on device):');
+        stdout.writeln('  $publicB64');
+        if (argResults!['save'] as bool) {
+          final file = configCandidates().first;
+          final json = file.existsSync() && file.readAsStringSync().trim().isNotEmpty
+              ? (jsonDecode(file.readAsStringSync()) as Map<String, dynamic>)
+              : <String, dynamic>{};
+          writePath(json, 'publicKey', publicB64);
+          _save(json);
+          stdout.writeln('');
+          stdout.writeln('Saved public key to ${file.path}');
+        }
+      });
+
+  void _save(Map<String, dynamic> json) {
+    final file = configCandidates().first;
+    file.parent.createSync(recursive: true);
+    file.writeAsStringSync(const JsonEncoder.withIndent('  ').convert(json));
+  }
+}