@_nazmiforreal/flutter-ota 0.1.0 → 0.1.1

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

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

@@ -0,0 +1,132 @@
+import 'dart:io';
+
+import 'package:args/args.dart';
+import 'package:args/command_runner.dart';
+import 'package:path/path.dart' as p;
+import 'package:postgres/postgres.dart';
+
+import '../cli_base.dart';
+
+/// `flutter_patcher migrate` — run backend SQL migrations.
+class MigrateCommand extends Command<int> {
+  @override
+  String get name => 'migrate';
+
+  @override
+  String get description =>
+      'Run SQL migrations against the backend database (Supabase Postgres).';
+
+  @override
+  ArgParser get argParser => ArgParser()
+    ..addOption('backend', abbr: 'b', help: 'Backend provider.')
+    ..addOption('database-url',
+        help: 'Postgres connection string (or DATABASE_URL env).')
+    ..addOption('migrations-dir',
+        help: 'Directory of *.sql migration files (ordered by name).')
+    ..addFlag('dry-run', help: 'Print migrations instead of applying them.');
+
+  /// Default migrations dir lives next to the CLI entrypoint; the backend
+  /// selects which dialect's migrations are used (cloudflare = D1 SQLite).
+  String defaultMigrationsDir(String provider) {
+    final sub = switch (provider) {
+      'cloudflare' => 'cloudflare',
+      _ => 'supabase',
+    };
+    return p.join(p.dirname(Platform.script.path), '..', 'migrations', sub);
+  }
+
+  List<String> _splitStatements(String sql) {
+    return sql
+        .split(';')
+        .map((s) => s.trim())
+        .where((s) => s.isNotEmpty && !s.startsWith('--'))
+        .toList();
+  }
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        final provider = argResults!['backend'] as String? ?? 'supabase';
+        final dir = argResults!['migrations-dir'] as String? ??
+            defaultMigrationsDir(provider);
+        final migrationsDir = Directory(dir);
+        if (!migrationsDir.existsSync()) {
+          throw StateError('Migrations directory not found: $dir');
+        }
+        final files = migrationsDir
+            .listSync()
+            .whereType<File>()
+            .where((f) => f.path.endsWith('.sql'))
+            .toList()
+          ..sort((a, b) => a.path.compareTo(b.path));
+        if (files.isEmpty) {
+          throw StateError('No *.sql files in $dir');
+        }
+
+        if (argResults!['dry-run'] as bool) {
+          for (final f in files) {
+            stdout.writeln('--- ${p.basename(f.path)} ---');
+            stdout.writeln(f.readAsStringSync());
+          }
+          return;
+        }
+
+        final url = argResults!['database-url'] as String? ??
+            Platform.environment['DATABASE_URL'];
+        if (provider == 'cloudflare' || provider == 'aws') {
+          stdout.writeln(
+            'Migrations for "$provider" are applied via its platform tooling '
+            '(e.g. `wrangler d1 execute` for cloudflare, or the AWS console for '
+            'S3/DynamoDB). The SQL above shows the intended schema.',
+          );
+          return;
+        }
+        if (url == null || url.isEmpty) {
+          throw StateError('Provide --database-url or set DATABASE_URL.');
+        }
+
+        final uri = Uri.parse(url);
+        final endpoint = Endpoint(
+          host: uri.host,
+          port: uri.port == 0 ? 5432 : uri.port,
+          database: uri.path.isEmpty ? 'postgres' : uri.path.substring(1),
+          username: uri.userInfo.isEmpty ? null : uri.userInfo.split(':').first,
+          password: uri.userInfo.contains(':')
+              ? uri.userInfo.split(':').last
+              : null,
+        );
+        final conn = await Connection.open(
+          endpoint,
+          settings: ConnectionSettings(sslMode: SslMode.disable),
+        );
+        try {
+          await conn.execute(
+            'CREATE TABLE IF NOT EXISTS _flutter_patcher_migrations '
+            '(name text primary key, applied_at timestamptz default now())',
+            queryMode: QueryMode.simple,
+          );
+          for (final file in files) {
+            final name = p.basename(file.path);
+            final escaped = name.replaceAll("'", "''");
+            final existing = await conn.execute(
+              "SELECT 1 FROM _flutter_patcher_migrations WHERE name = '$escaped'",
+              queryMode: QueryMode.simple,
+            );
+            if (existing.isNotEmpty) {
+              stdout.writeln('skip    $name (already applied)');
+              continue;
+            }
+            final statements = _splitStatements(file.readAsStringSync());
+            for (final stmt in statements) {
+              await conn.execute(stmt, queryMode: QueryMode.simple);
+            }
+            await conn.execute(
+              "INSERT INTO _flutter_patcher_migrations(name) VALUES ('$escaped')",
+              queryMode: QueryMode.simple,
+            );
+            stdout.writeln('applied $name');
+          }
+        } finally {
+          await conn.close();
+        }
+      });
+}

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

@@ -0,0 +1,41 @@
+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 rollback` — disable the latest enabled bundle on a channel.
+class RollbackCommand extends Command<int> {
+  RollbackCommand({this.config, this.backendOverride});
+
+  final FlutterPatcherConfig? config;
+  final Backend? backendOverride;
+
+  @override
+  String get name => 'rollback';
+
+  @override
+  String get description =>
+      'Disable the latest enabled bundle on a channel (roll back).';
+
+  @override
+  ArgParser get argParser => ArgParser()
+    ..addOption('backend', abbr: 'b', help: 'Backend provider.')
+    ..addOption('channel', abbr: 'c', help: 'Channel to roll back.');
+
+  @override
+  Future<int> run() => runGuarded(() async {
+        final channel = argResults!['channel'] as String?;
+        if (channel == null || channel.isEmpty) {
+          throw StateError('Usage: flutter_patcher rollback --channel <channel>');
+        }
+        final cfg = effectiveConfig(config ?? loadConfig(), argResults!);
+        final backend = requireBackend(cfg, override: backendOverride);
+        final id = await rollbackChannel(backend, channel);
+        stdout.writeln('Rolled back channel "$channel" (disabled bundle $id)');
+      });
+}