@_nazmiforreal/flutter-ota 0.1.12 → 0.1.13

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

@@ -91,8 +91,9 @@ PackResult _writePatchPackage({
 }) {
   // When an ABI is requested, restrict the patch to only that ABI instead of
   // shipping every architecture found in the APK.
-  final effectiveLibs =
-      abi == null ? libs : libs.where((e) => e.$1 == abi).toList();
+  final effectiveLibs = abi == null
+      ? libs
+      : libs.where((e) => e.$1 == abi).toList();
   final patchFiles = <String, _PatchAssetFile>{};
   final operations = <Map<String, dynamic>>[];
   var baseManifestSize = 0;
@@ -115,17 +116,12 @@ PackResult _writePatchPackage({
     for (final key in requestedAssets) {
       final variantsRaw = assetManifest[key];
       if (variantsRaw is! List) {
-        throw PackException(
-            'asset key not found in AssetManifest.bin: $key');
+        throw PackException('asset key not found in AssetManifest.bin: $key');
       }
       final variants = variantsRaw
           .map((variant) => Map<String, dynamic>.from(variant as Map))
           .toList(growable: false);
-      operations.add({
-        'op': 'upsert',
-        'key': key,
-        'variants': variants,
-      });
+      operations.add({'op': 'upsert', 'key': key, 'variants': variants});
       for (final variant in variants) {
         final assetPath = variant['asset'];
         if (assetPath is! String || assetPath.isEmpty) {
@@ -150,10 +146,11 @@ PackResult _writePatchPackage({
   }
 
   final libManifest = <String, dynamic>{
-    for (final (currentAbi, soBytes) in effectiveLibs) currentAbi: {
-      'path': 'lib/$currentAbi/libapp.so',
-      'md5': md5.convert(soBytes).toString(),
-    },
+    for (final (currentAbi, soBytes) in effectiveLibs)
+      currentAbi: {
+        'path': 'lib/$currentAbi/libapp.so',
+        'md5': md5.convert(soBytes).toString(),
+      },
   };
 
   final zipManifest = <String, dynamic>{
@@ -167,11 +164,13 @@ PackResult _writePatchPackage({
         'manifestPatch': 'manifest_patch.json',
         'prefix': 'assets/',
         'files': patchFiles.values
-            .map((file) => {
-                  'path': file.path,
-                  'md5': file.md5Hex,
-                  'size': file.bytes.length,
-                })
+            .map(
+              (file) => {
+                'path': file.path,
+                'md5': file.md5Hex,
+                'size': file.bytes.length,
+              },
+            )
             .toList(),
       },
   };
@@ -183,7 +182,8 @@ PackResult _writePatchPackage({
   var progressDone = 0;
   for (final (currentAbi, soBytes) in effectiveLibs) {
     package.addFile(
-        ArchiveFile('lib/$currentAbi/libapp.so', soBytes.length, soBytes));
+      ArchiveFile('lib/$currentAbi/libapp.so', soBytes.length, soBytes),
+    );
     progressDone++;
     onProgress?.call(progressDone, progressTotal, 'lib/$currentAbi/libapp.so');
   }
@@ -204,8 +204,7 @@ PackResult _writePatchPackage({
   }
 
   // archive 3.x returns List<int>?, 4.x returns List<int>; coerce to bytes.
-  // ignore: unnecessary_nullable_for_final_variable_declarations, dead_null_aware_expression
-  final List<int> packageBytes = ZipEncoder().encode(package) ?? const <int>[];
+  final List<int> packageBytes = ZipEncoder().encode(package);
   final outZip = File('${outDir.path}/patch.zip');
   outZip.writeAsBytesSync(packageBytes);
   onProgress?.call(progressTotal, progressTotal, 'patch.zip');
@@ -233,8 +232,9 @@ PackResult _writePatchPackage({
 }
 
 ArchiveFile _jsonArchiveFile(String name, Map<String, dynamic> json) {
-  final bytes =
-      utf8.encode('${const JsonEncoder.withIndent('  ').convert(json)}\n');
+  final bytes = utf8.encode(
+    '${const JsonEncoder.withIndent('  ').convert(json)}\n',
+  );
   return ArchiveFile(name, bytes.length, bytes);
 }
 
@@ -271,7 +271,8 @@ ArchiveFile? _findFile(Archive archive, String name) {
 
 void _writeJson(File file, Map<String, dynamic> json) {
   file.writeAsStringSync(
-      '${const JsonEncoder.withIndent('  ').convert(json)}\n');
+    '${const JsonEncoder.withIndent('  ').convert(json)}\n',
+  );
 }
 
 void _validateArchiveRelativePath(String path, String label) {
@@ -429,4 +430,4 @@ class _FlutterStandardMessageCodec {
       throw PackException('truncated AssetManifest.bin');
     }
   }
-}
+}

package/dart-src/packages/cli-tools/lib/src/pocketbase/data_bootstrap.dart

@@ -0,0 +1,39 @@
+/// Bootstraps a fresh PocketBase data directory with the flutter_ota_kit
+/// schema defaults (hooks, settings) the first time PB is started.
+library;
+
+import 'dart:io';
+
+import 'package:path/path.dart' as p;
+
+/// Copies the bundled hooks into `pb_data/pb_hooks/` so PB picks them up on
+/// the next `serve`. Existing files are left alone so user edits are kept.
+class PocketBaseDataBootstrap {
+  const PocketBaseDataBootstrap({
+    required this.dataDir,
+    required this.hooksSourceDir,
+  });
+
+  final Directory dataDir;
+  final Directory hooksSourceDir;
+
+  Future<List<String>> install() async {
+    await dataDir.create(recursive: true);
+    final hooksDir = Directory(p.join(dataDir.path, 'pb_hooks'));
+    await hooksDir.create(recursive: true);
+    final installed = <String>[];
+    if (!hooksSourceDir.existsSync()) {
+      return installed;
+    }
+    for (final entry in hooksSourceDir.listSync()) {
+      if (entry is! File) continue;
+      if (!entry.path.endsWith('.pb.js')) continue;
+      final out = File(p.join(hooksDir.path, p.basename(entry.path)));
+      if (!await out.exists()) {
+        await entry.copy(out.path);
+        installed.add(p.basename(entry.path));
+      }
+    }
+    return installed;
+  }
+}

package/dart-src/packages/cli-tools/lib/src/pocketbase/hooks/bundles.pb.js

@@ -0,0 +1,56 @@
+/// <reference path="../pb_data/types.d.ts" />
+
+// PocketBase JS hook: validate and enrich bundle records on create.
+// Runs inside the PB Go binary's embedded JS VM (goja). Use $app.dao() to
+// query, $app.settings() to read config, $apis.request() to call webhooks.
+
+/** @type {OnRecordCreateRequestHandler} */
+onRecordCreateRequest((e) => {
+    // Reject bundles that look malformed.
+    const b = e.record;
+    if (!b.get("channel") || !b.get("platform") || !b.get("file_hash")) {
+        throw new BadRequestError("channel, platform and file_hash are required");
+    }
+    if (b.getString("platform").length > 16) {
+        throw new BadRequestError("platform must be <= 16 chars");
+    }
+    if (b.getInt("rollout_cohort_count") > 1000) {
+        throw new BadRequestError("rollout_cohort_count must be 0..1000");
+    }
+
+    // Append to the audit log.
+    const audit = $app.dao().findCollectionByNameOrId("audit_log");
+    const row = new Record(audit, {
+        action: "deploy",
+        bundle_id: b.get("id"),
+        channel: b.get("channel"),
+        details: JSON.stringify({
+            platform: b.get("platform"),
+            message: b.get("message"),
+            should_force_update: b.getBool("should_force_update"),
+        }),
+    });
+    $app.dao().save(row);
+
+    e.next();
+}, "bundles");
+
+/** @type {OnRecordUpdateRequestHandler} */
+onRecordUpdateRequest((e) => {
+    const b = e.record;
+    if (b.getInt("rollout_cohort_count") > 1000) {
+        throw new BadRequestError("rollout_cohort_count must be 0..1000");
+    }
+    e.next();
+}, "bundles");
+
+/** @type {OnRecordDeleteRequestHandler} */
+onRecordDeleteRequest((e) => {
+    const audit = $app.dao().findCollectionByNameOrId("audit_log");
+    const row = new Record(audit, {
+        action: "delete_bundle",
+        bundle_id: e.record.get("id"),
+    });
+    $app.dao().save(row);
+    e.next();
+}, "bundles");

package/dart-src/packages/cli-tools/lib/src/pocketbase/installer.dart

@@ -0,0 +1,189 @@
+/// Manages the PocketBase server binary — download, version, run, upgrade.
+///
+/// PocketBase is a single Go binary (~15MB) that the CLI can download
+/// automatically on first run. The binary is cached in
+/// `~/.flutter_ota_kit/pocketbase/` so subsequent `serve` invocations are
+/// instant.
+///
+/// Supported platforms: linux/amd64, linux/arm64, macos/amd64, macos/arm64,
+/// windows/amd64. Other combinations fall back to a helpful error.
+library;
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:archive/archive.dart';
+import 'package:http/http.dart' as http;
+import 'package:path/path.dart' as p;
+
+/// Default PocketBase version managed by the CLI. Bumped in lockstep with
+/// the rest of the stack.
+const String kDefaultPocketBaseVersion = '0.22.21';
+
+/// Where the binary + extracted files live.
+class PocketBaseInstallPaths {
+  const PocketBaseInstallPaths({
+    required this.installDir,
+    required this.binaryPath,
+  });
+
+  /// `~/.flutter_ota_kit/pocketbase/<version>/`
+  final Directory installDir;
+
+  /// `~/.flutter_ota_kit/pocketbase/<version>/pocketbase`
+  /// (or `pocketbase.exe` on Windows).
+  final File binaryPath;
+
+  String get version => p.basename(installDir.path);
+
+  static PocketBaseInstallPaths resolve({
+    String? version = kDefaultPocketBaseVersion,
+    Directory? root,
+  }) {
+    final base =
+        root ??
+        Directory(
+          p.join(
+            Platform.environment['HOME'] ??
+                Platform.environment['USERPROFILE'] ??
+                '.',
+            '.flutter_ota_kit',
+            'pocketbase',
+            version!,
+          ),
+        );
+    final exe = Platform.isWindows ? 'pocketbase.exe' : 'pocketbase';
+    return PocketBaseInstallPaths(
+      installDir: base,
+      binaryPath: File(p.join(base.path, exe)),
+    );
+  }
+}
+
+class _OsArch {
+  const _OsArch(this.os, this.arch, this.assetSuffix);
+  final String os;
+  final String arch;
+  final String assetSuffix;
+}
+
+_OsArch _detectOsArch() {
+  // Map Platform.operatingSystem + Platform.numberOfProcessors to a PB asset.
+  // PB asset names: linux_amd64, linux_arm64, darwin_amd64, darwin_arm64,
+  // windows_amd64.
+  final os = Platform.operatingSystem;
+  String assetOs;
+  if (os == 'linux') {
+    assetOs = 'linux';
+  } else if (os == 'macos') {
+    assetOs = 'darwin';
+  } else if (os == 'windows') {
+    assetOs = 'windows';
+  } else {
+    throw StateError('Unsupported OS for PocketBase: $os');
+  }
+  // Dart on ARM Macs returns 'macos' with arm64 in the version string; we
+  // detect arm64 via the Dart version since `Platform` doesn't expose arch
+  // directly in stable Dart.
+  final dartVersion = Platform.version.toLowerCase();
+  final isArm =
+      dartVersion.contains('arm64') || dartVersion.contains('aarch64');
+  final arch = isArm ? 'arm64' : 'amd64';
+  return _OsArch(os, arch, '${assetOs}_$arch');
+}
+
+/// Outcome of [PocketBaseInstaller.ensureInstalled].
+class PocketBaseInstallResult {
+  const PocketBaseInstallResult({
+    required this.paths,
+    required this.alreadyInstalled,
+    required this.bytesDownloaded,
+  });
+
+  final PocketBaseInstallPaths paths;
+  final bool alreadyInstalled;
+  final int bytesDownloaded;
+}
+
+/// Downloads, extracts, and verifies the PocketBase binary.
+class PocketBaseInstaller {
+  PocketBaseInstaller({http.Client? httpClient, String? version})
+    : _http = httpClient ?? http.Client(),
+      _version = version ?? kDefaultPocketBaseVersion;
+
+  final http.Client _http;
+  final String _version;
+
+  /// Returns the install paths and the binary is guaranteed to exist on disk.
+  Future<PocketBaseInstallResult> ensureInstalled({
+    PocketBaseInstallPaths? paths,
+    void Function(double progress)? onProgress,
+  }) async {
+    final install = paths ?? PocketBaseInstallPaths.resolve(version: _version);
+    if (await install.binaryPath.exists()) {
+      return PocketBaseInstallResult(
+        paths: install,
+        alreadyInstalled: true,
+        bytesDownloaded: 0,
+      );
+    }
+    await install.installDir.create(recursive: true);
+
+    final osArch = _detectOsArch();
+    final url = Uri.parse(
+      'https://github.com/pocketbase/pocketbase/releases/download/'
+      'v$_version/pocketbase_${_version}_${osArch.assetSuffix}.zip',
+    );
+    final req = http.Request('GET', url);
+    final streamed = await _http.send(req);
+    if (streamed.statusCode != 200) {
+      throw StateError(
+        'Failed to download PocketBase v$_version for ${osArch.assetSuffix}: '
+        'HTTP ${streamed.statusCode}. Check your internet connection or set '
+        '--pb-version to a known-good release.',
+      );
+    }
+    final bytes = <int>[];
+    var received = 0;
+    final total = streamed.contentLength ?? 0;
+    await for (final chunk in streamed.stream) {
+      bytes.addAll(chunk);
+      received += chunk.length;
+      if (onProgress != null && total > 0) {
+        onProgress(received / total);
+      }
+    }
+    final zipPath = File(p.join(install.installDir.path, 'pocketbase.zip'))
+      ..writeAsBytesSync(bytes);
+
+    // Extract just the binary (skip the README/CHANGELOG that ship in the
+    // archive to keep the install dir tidy).
+    final archive = ZipDecoder().decodeBytes(bytes);
+    for (final entry in archive) {
+      if (!entry.isFile) continue;
+      final entryName = entry.name.split('/').last;
+      if (entryName == 'pocketbase' || entryName == 'pocketbase.exe') {
+        final out = File(p.join(install.installDir.path, entryName));
+        out.writeAsBytesSync(entry.content as List<int>);
+        if (!Platform.isWindows) {
+          Process.runSync('chmod', ['+x', out.path]);
+        }
+      }
+    }
+    try {
+      await zipPath.delete();
+    } catch (_) {
+      // best-effort cleanup
+    }
+
+    return PocketBaseInstallResult(
+      paths: install,
+      alreadyInstalled: false,
+      bytesDownloaded: bytes.length,
+    );
+  }
+
+  /// Resolves the install paths without downloading.
+  PocketBaseInstallPaths paths() =>
+      PocketBaseInstallPaths.resolve(version: _version);
+}

package/dart-src/packages/cli-tools/lib/src/pocketbase/process_manager.dart

@@ -0,0 +1,123 @@
+/// Spawns the PocketBase binary as a child process, capturing its stdout/stderr
+/// and providing clean start/stop semantics.
+///
+/// PB reads its data directory from the `--dir` flag (default `./pb_data`).
+/// The CLI's installer pre-creates that directory and copies hooks into
+/// `pb_data/pb_hooks/` before the first start.
+library;
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:path/path.dart' as p;
+
+class PocketBaseProcess {
+  PocketBaseProcess._(this.process, this.dataDir, this.binaryPath);
+
+  final Process process;
+  final Directory dataDir;
+  final File binaryPath;
+
+  bool get isRunning => true; // Process instance is always present after start.
+
+  int get pid => process.pid;
+
+  Future<int> get exitCode => process.exitCode;
+
+  /// Returns the stdout/stderr streams merged.
+  Stream<List<int>> get output => process.stdout;
+  Stream<List<int>> get errors => process.stderr;
+
+  /// Send SIGINT (Ctrl+C) for a graceful shutdown, then SIGKILL if needed.
+  Future<void> stop({Duration timeout = const Duration(seconds: 5)}) async {
+    if (Platform.isWindows) {
+      process.kill();
+    } else {
+      process.kill(ProcessSignal.sigint);
+    }
+    try {
+      await process.exitCode.timeout(timeout);
+    } on TimeoutException {
+      process.kill(ProcessSignal.sigkill);
+    }
+  }
+}
+
+class PocketBaseProcessManager {
+  PocketBaseProcessManager({
+    required this.binaryPath,
+    required this.dataDir,
+    this.port = 8090,
+    this.host = '127.0.0.1',
+  });
+
+  final File binaryPath;
+  final Directory dataDir;
+  final int port;
+  final String host;
+
+  PocketBaseProcess? _process;
+  PocketBaseProcess? get process => _process;
+
+  /// Start PB in the background. Returns once PB is listening (or after a
+  /// short timeout waiting for it to come up).
+  Future<PocketBaseProcess> start({
+    Map<String, String>? env,
+    String? adminEmail,
+    String? adminPassword,
+    Duration readyTimeout = const Duration(seconds: 15),
+  }) async {
+    if (_process != null) {
+      throw StateError('PocketBase is already running (pid ${_process!.pid})');
+    }
+    if (!await binaryPath.exists()) {
+      throw StateError(
+        'PocketBase binary not found at ${binaryPath.path}. '
+        'Run `flutter_ota_kit pocketbase install` first.',
+      );
+    }
+    await dataDir.create(recursive: true);
+    final hooksDir = Directory(p.join(dataDir.path, 'pb_hooks'));
+    await hooksDir.create(recursive: true);
+
+    final mergedEnv = <String, String>{
+      ...Platform.environment,
+      if (adminEmail != null) 'PB_ADMIN_EMAIL': adminEmail,
+      if (adminPassword != null) 'PB_ADMIN_PASSWORD': adminPassword,
+      ...?env,
+    };
+
+    final proc = await Process.start(
+      binaryPath.path,
+      ['serve', '--http=${host}:$port', '--dir=${dataDir.path}'],
+      environment: mergedEnv,
+      mode: ProcessStartMode.detached,
+    );
+
+    // Wait for the health endpoint to come up (best-effort; fall through
+    // after readyTimeout either way).
+    final deadline = DateTime.now().add(readyTimeout);
+    while (DateTime.now().isBefore(deadline)) {
+      try {
+        final socket = await Socket.connect(
+          host,
+          port,
+          timeout: const Duration(milliseconds: 250),
+        );
+        socket.destroy();
+        break;
+      } catch (_) {
+        await Future<void>.delayed(const Duration(milliseconds: 200));
+      }
+    }
+    _process = PocketBaseProcess._(proc, dataDir, binaryPath);
+    return _process!;
+  }
+
+  Future<void> stop() async {
+    final proc = _process;
+    if (proc == null) return;
+    await proc.stop();
+    _process = null;
+  }
+}