avd_manager 1.0.4

package/lib/avd_utils.dart

@@ -0,0 +1,186 @@
+import 'dart:convert';
+import 'dart:io';
+import 'package:path/path.dart' as p;
+import 'package:args/args.dart';
+
+class AvdInfo {
+  final String name;
+  final int sizeBytes;
+
+  AvdInfo({required this.name, required this.sizeBytes});
+}
+
+// Function to parse the command-line arguments and return a Map
+Map<String, String> parseArguments(List<String> arguments) {
+  final parser = ArgParser();
+  parser.addOption('sort', defaultsTo: 'name');
+  parser.addOption('min-size', defaultsTo: '0');
+
+  final argResults = parser.parse(arguments);
+
+  return {
+    'sort': argResults['sort'] ?? 'name',
+    'min-size': argResults['min-size'] ?? '0',
+  };
+}
+
+Future<List<AvdInfo>> getAvailableAvds() async {
+  final avdHome = Platform.environment['ANDROID_AVD_HOME'] ??
+      p.join(Platform.environment['HOME']!, '.android', 'avd');
+
+  final avdDirectory = Directory(avdHome);
+  if (!await avdDirectory.exists()) {
+    print('❌ AVD directory does not exist at $avdHome');
+    return [];
+  }
+
+  final avdDirs = await avdDirectory
+      .list()
+      .where((entity) => entity is Directory && entity.path.endsWith('.avd'))
+      .toList();
+
+  List<AvdInfo> avds = [];
+  for (final entity in avdDirs) {
+    final dir = entity as Directory;
+    final size = await _getDirectorySize(dir);
+    final name = p.basenameWithoutExtension(dir.path);
+    avds.add(AvdInfo(name: name, sizeBytes: size));
+  }
+
+  return avds;
+}
+
+Future<int> _getDirectorySize(Directory dir) async {
+  int size = 0;
+  await for (var entity in dir.list(recursive: true)) {
+    if (entity is File) {
+      size += await entity.length();
+    }
+  }
+  return size;
+}
+
+Future<ProcessResult> runAvdManager(List<String> args) async {
+  final javaHomeExpr = Platform.isMacOS ? r'$(echo $JAVA_HOME)' : r'$JAVA_HOME';
+  final fullCommand =
+      'export JAVA_HOME=$javaHomeExpr && avdmanager ${args.map((a) => '"$a"').join(' ')}';
+  return await Process.run(
+    'bash',
+    ['-lc', fullCommand],
+  );
+}
+
+Future<ProcessResult> runSdkManager(List<String> args) async {
+  final environment = Map<String, String>.from(Platform.environment);
+  final javaHome = Platform.environment['JAVA_HOME'];
+  if (javaHome != null) {
+    environment['JAVA_HOME'] = javaHome;
+  }
+
+  final process = await Process.start(
+    'sdkmanager',
+    ['--install', ...args],
+    environment: environment,
+    runInShell: false,
+  );
+
+  // Pre-answer any prompt with yes so sdkmanager can proceed.
+  for (var i = 0; i < 20; i++) {
+    process.stdin.writeln('y');
+  }
+  await process.stdin.close();
+
+  final stdoutBuffer = StringBuffer();
+  final stderrBuffer = StringBuffer();
+
+  final stdoutDone = process.stdout.transform(utf8.decoder).forEach((chunk) {
+    stdoutBuffer.write(chunk);
+    stdout.write(chunk);
+  });
+
+  final stderrDone = process.stderr.transform(utf8.decoder).forEach((chunk) {
+    stderrBuffer.write(chunk);
+    stderr.write(chunk);
+  });
+
+  final exitCode = await process.exitCode.timeout(
+    const Duration(minutes: 30),
+    onTimeout: () {
+      process.kill(ProcessSignal.sigkill);
+      return -1;
+    },
+  );
+
+  await Future.wait([stdoutDone, stderrDone]);
+
+  return ProcessResult(
+    process.pid,
+    exitCode,
+    stdoutBuffer.toString(),
+    stderrBuffer.toString(),
+  );
+}
+
+Future<void> createAndPatchAvd(String name,
+    {required String device, required String systemImage}) async {
+  print('📦 Ensuring system image is installed...');
+  final sdkResult = await runSdkManager([systemImage]);
+  if (sdkResult.exitCode == -1) {
+    print('❌ System image installation timed out after 30 minutes.');
+    print('Attempted system image package: $systemImage');
+    print('This can happen when the image is large or your network is slow.');
+    print('Please verify that sdkmanager is available and retry.');
+    print('stdout:\n${sdkResult.stdout}');
+    print('stderr:\n${sdkResult.stderr}');
+    return;
+  }
+
+  if (sdkResult.exitCode != 0) {
+    print('❌ Failed to install system image: $systemImage');
+    print('stdout:\n${sdkResult.stdout}');
+    print('stderr:\n${sdkResult.stderr}');
+    return;
+  }
+
+  print('🧰 Creating AVD...');
+  final javaHomeExpr = Platform.isMacOS ? r'$(echo $JAVA_HOME)' : r'$JAVA_HOME';
+
+  final command = '''
+    export JAVA_HOME=$javaHomeExpr;
+    echo no | avdmanager create avd -n "$name" -k "$systemImage" --device "$device"
+  ''';
+
+  final result = await Process.run(
+    'bash',
+    ['-c', command],
+    runInShell: true,
+  );
+
+  if (result.exitCode != 0) {
+    print('❌ Failed to create AVD:\n${result.stdout}\n${result.stderr}');
+    return;
+  }
+
+  print('✅ AVD $name created successfully.');
+
+  // Confirm AVD actually exists
+  final avdHome = Platform.environment['ANDROID_AVD_HOME'] ??
+      '${Platform.environment['HOME']}/.android/avd';
+  final configPath = '$avdHome/$name.avd/config.ini';
+  final configFile = File(configPath);
+
+  if (!configFile.existsSync()) {
+    print('❌ Could not find config.ini for $name.');
+    return;
+  }
+
+  print('🔧 Patching config.ini for performance...');
+  var config = configFile.readAsStringSync();
+  if (!config.contains('hw.gpu.enabled')) {
+    config += '\nhw.gpu.enabled=yes\nhw.gpu.mode=auto\n';
+    configFile.writeAsStringSync(config);
+    print('✅ Patched config.ini for GPU acceleration.');
+  } else {
+    print('config.ini already patched.');
+  }
+}

package/lib/commands/create.dart

@@ -0,0 +1,86 @@
+import 'dart:io';
+import 'package:avd_manager/avd_utils.dart';
+
+Future<List<String>> listAvailableDevices() async {
+  final result = await runAvdManager(['list', 'device']);
+  if (result.exitCode != 0) {
+    print('❌ Failed to list devices');
+    return [];
+  }
+
+  final devices = <String>[];
+  final regex = RegExp(r'id: \d+ or "(.*?)"');
+  for (final line in result.stdout.toString().split('\n')) {
+    final match = regex.firstMatch(line);
+    if (match != null) {
+      devices.add(match.group(1)!);
+    }
+  }
+
+  if (devices.isEmpty) {
+    print('⚠️ No devices found.');
+    return [];
+  }
+  return devices;
+}
+
+Future<String?> promptForDevice(List<String> devices) async {
+  print('\n📱 Available Devices:\n');
+  for (int i = 0; i < devices.length; i++) {
+    print('  [${i + 1}] ${devices[i]}');
+  }
+  stdout.write('\nEnter device number: ');
+  final input = stdin.readLineSync();
+  final index = int.tryParse(input ?? '');
+  if (index != null && index > 0 && index <= devices.length) {
+    return devices[index - 1];
+  }
+  print('❌ Invalid selection.');
+  return null;
+}
+
+Future<void> createAvd(String name,
+    {String? device, required String apiLevel, String? abi}) async {
+  final systemImage = await _getSystemImage(apiLevel, abi: abi);
+
+  device ??= await _selectDevice();
+  if (device == null) {
+    print('❌ No device selected.');
+    return;
+  }
+
+  await createAndPatchAvd(name, device: device, systemImage: systemImage);
+}
+
+Future<String> _getSystemImage(String apiLevel, {String? abi}) async {
+  final selectedAbi = abi ?? await _resolveDefaultAbi();
+
+  if (selectedAbi.isEmpty) {
+    return 'system-images;android-$apiLevel;google_apis;x86';
+  }
+
+  return 'system-images;android-$apiLevel;google_apis;$selectedAbi';
+}
+
+Future<String> _resolveDefaultAbi() async {
+  try {
+    final result = await Process.run('uname', ['-m']);
+    final hostArch = result.stdout.toString().trim().toLowerCase();
+    if (hostArch == 'arm64' || hostArch == 'aarch64') {
+      return 'arm64-v8a';
+    }
+    if (hostArch == 'x86_64' || hostArch == 'amd64') {
+      return 'x86';
+    }
+  } catch (_) {
+    // ignore and fall back to x86
+  }
+
+  return 'x86';
+}
+
+Future<String?> _selectDevice() async {
+  final devices = await listAvailableDevices();
+  if (devices.isEmpty) return null;
+  return await promptForDevice(devices);
+}

package/lib/commands/delete.dart

@@ -0,0 +1,31 @@
+import 'dart:io';
+import 'package:path/path.dart' as p;
+
+Future<void> deleteAvd(String name) async {
+  final avdHome = Platform.environment['ANDROID_AVD_HOME'] ??
+      p.join(Platform.environment['HOME']!, '.android', 'avd');
+  final iniPath = p.join(avdHome, '$name.ini');
+  final avdPath = p.join(avdHome, '$name.avd');
+
+  final iniFile = File(iniPath);
+  final avdDir = Directory(avdPath);
+
+  if (!await iniFile.exists() && !await avdDir.exists()) {
+    print('❌ AVD "$name" does not exist.');
+    return;
+  }
+
+  try {
+    if (await iniFile.exists()) {
+      await iniFile.delete();
+      print('🗑️ Deleted $iniPath');
+    }
+    if (await avdDir.exists()) {
+      await avdDir.delete(recursive: true);
+      print('🗑️ Deleted $avdPath');
+    }
+    print('✅ AVD "$name" deleted successfully.');
+  } catch (e) {
+    print('❌ Failed to delete AVD "$name": $e');
+  }
+}

package/lib/commands/launch.dart

@@ -0,0 +1,68 @@
+import 'dart:io';
+import 'package:process_run/shell.dart';
+
+/// Lists available AVDs by reading ~/.android/avd directory
+Future<List<String>> listAvds() async {
+  final home = Platform.environment['HOME'] ?? '';
+  final avdDir = Directory('$home/.android/avd');
+  if (!await avdDir.exists()) return [];
+
+  final avds = <String>[];
+
+  await for (var entity in avdDir.list()) {
+    if (entity is File && entity.path.endsWith('.ini')) {
+      final name = entity.uri.pathSegments.last.replaceAll('.ini', '');
+      avds.add(name);
+    }
+  }
+
+  return avds;
+}
+
+/// Prompt the user to choose an AVD
+Future<String?> promptAvdSelection(List<String> avds) async {
+  print('\n📱 Available AVDs:\n');
+  for (int i = 0; i < avds.length; i++) {
+    print('  [${i + 1}] ${avds[i]}');
+  }
+
+  stdout.write('\nEnter AVD number to launch: ');
+  final input = stdin.readLineSync();
+  final index = int.tryParse(input ?? '');
+
+  if (index != null && index > 0 && index <= avds.length) {
+    return avds[index - 1];
+  }
+
+  print('❌ Invalid selection.');
+  return null;
+}
+
+/// Launches the given AVD with optional flags
+Future<void> launchAvd(String? name, {List<String>? extraArgs}) async {
+  final shell = Shell();
+
+  if (name == null) {
+    final avds = await listAvds();
+    if (avds.isEmpty) {
+      print('❌ No AVDs found.');
+      return;
+    }
+    name = await promptAvdSelection(avds);
+    if (name == null) return;
+  }
+
+  print('🚀 Launching AVD "$name"...');
+
+  final args = [
+    '-avd',
+    name,
+    ...?extraArgs,
+  ];
+
+  try {
+    await shell.run('emulator ${args.join(' ')}');
+  } catch (e) {
+    print('❌ Failed to launch AVD "$name": $e');
+  }
+}

package/lib/commands/list.dart

@@ -0,0 +1,183 @@
+import 'dart:io';
+import 'package:avd_manager/avd_utils.dart';
+import 'package:path/path.dart' as p;
+
+// parse size strings like "500MB" into bytes
+int parseSize(String input) {
+  if (input.isEmpty) {
+    throw FormatException('Size cannot be empty');
+  }
+  final pattern = RegExp(r'^(\d+(?:\.\d+)?)([KMG]B)$', caseSensitive: false);
+  final match = pattern.firstMatch(input.trim());
+
+  if (match == null) {
+    throw FormatException(
+        'Invalid size format: $input. Use formats like 500MB or 1GB');
+  }
+
+  final value = double.parse(match.group(1)!); // The numeric part
+  if (value <= 0) {
+    throw FormatException('Size must be greater than 0');
+  }
+  final unit = match.group(2)!.toUpperCase(); // The unit (MB, GB, etc.)
+
+  switch (unit) {
+    case 'KB':
+      return (value * 1024).toInt();
+    case 'MB':
+      return (value * 1024 * 1024).toInt(); // Convert MB to bytes
+    case 'GB':
+      return (value * 1024 * 1024 * 1024).toInt(); // Convert GB to bytes
+    default:
+      throw FormatException('Unknown size unit: $unit');
+  }
+}
+
+/// Format size strings like "500MB" into bytes
+String formatSize(int bytes) {
+  if (bytes >= 1 << 30) return '${(bytes / (1 << 30)).toStringAsFixed(2)} GB';
+  if (bytes >= 1 << 20) return '${(bytes / (1 << 20)).toStringAsFixed(2)} MB';
+  if (bytes >= 1 << 10) return '${(bytes / (1 << 10)).toStringAsFixed(2)} KB';
+  return '$bytes B';
+}
+
+// Define a simple class to hold AVD data
+class Avd {
+  final String name;
+  final int size;
+  final String sizeStr;
+
+  Avd(this.name, this.size, this.sizeStr);
+}
+
+/// ## ✅ Helper: `_getDirectorySize()
+Future<int> _getDirectorySize(Directory directory) async {
+  int totalSize = 0;
+  if (await directory.exists()) {
+    await for (final fileSystemEntity in directory.list(recursive: true)) {
+      if (fileSystemEntity is File) {
+        totalSize += await fileSystemEntity.length();
+      }
+    }
+  }
+  return totalSize;
+}
+
+String _formatSize(int bytes) {
+  const units = ['B', 'KB', 'MB', 'GB'];
+  double size = bytes.toDouble();
+  int unit = 0;
+
+  while (size > 1024 && unit < units.length - 1) {
+    size /= 1024;
+    unit++;
+  }
+
+  return '${size.toStringAsFixed(2)} ${units[unit]}';
+}
+
+/// ## ✅ Main Listing Function
+
+Future<void> listAvds(Map<String, String> cmd) async {
+  // Get AVD home directory
+  final avdHome = Platform.environment['ANDROID_AVD_HOME'] ??
+      p.join(Platform.environment['HOME']!, '.android', 'avd');
+
+  final avdDir = Directory(avdHome);
+
+  if (!await avdDir.exists()) {
+    print('❌ AVD directory not found at $avdHome');
+    return;
+  }
+
+  // List all AVD directories
+  final avdDirectories = avdDir.listSync().whereType<Directory>();
+  final avdData = <Avd>[];
+
+  // Fetch size for each AVD asynchronously and build Avd objects
+  for (final avd in avdDirectories) {
+    final name = p.basenameWithoutExtension(avd.path);
+    final size = await _getDirectorySize(avd);
+    final sizeStr = _formatSize(size);
+    avdData.add(Avd(name, size, sizeStr));
+  }
+
+  // Minimum AVDs check
+  if (avdData.isEmpty) {
+    print('No AVDs found.');
+    return;
+  }
+
+  // Extract command-line arguments
+  final sortBy = cmd['sort'] ?? 'name';
+  final minSizeStr = cmd['min-size'] ?? '0';
+  final nameStr = cmd['name'] ?? 'list';
+
+  // Skip size filtering if 'min-size' is '0'
+  if (minSizeStr != '0' && minSizeStr.isNotEmpty) {
+    try {
+      final minBytes = parseSize(minSizeStr);
+      avdData.removeWhere((avd) => avd.size <= minBytes);
+      final remainingCount = avdData.length;
+      if (remainingCount == 0) {
+        print(
+            'No AVDs found with size greater than ${minSizeStr.toUpperCase()}');
+        return;
+      } else {
+        print(
+            'Found $remainingCount AVD(s) with size greater than ${minSizeStr.toUpperCase()}:');
+      }
+      //sort list avds by name
+      if (nameStr == 'list') {
+        avdData.sort(
+            (a, b) => a.name.toLowerCase().compareTo(b.name.toLowerCase()));
+      } else if (nameStr == 'size') {
+        avdData.sort((a, b) => a.size.compareTo(b.size));
+      } else {
+        print('Invalid sort option: $nameStr. Defaulting to sorting by name.');
+        avdData.sort(
+            (a, b) => a.name.toLowerCase().compareTo(b.name.toLowerCase()));
+      }
+    } catch (e) {
+      print(
+          '❌ Invalid size format: $minSizeStr. Use formats like 500MB or 1GB.');
+      return;
+    }
+  }
+
+  // Sort AVDs if 'sort' argument is provided
+  if (sortBy == 'size') {
+    avdData.sort((a, b) => a.size.compareTo(b.size));
+  } else if (sortBy == 'name') {
+    avdData
+        .sort((a, b) => a.name.toLowerCase().compareTo(b.name.toLowerCase()));
+  }
+
+  // Loop and print the sorted AVD data
+  for (final avd in avdData) {
+    print('• ${avd.name} (AVD directory size: ${avd.sizeStr})');
+  }
+}
+
+/// ## ✅ Helper: `getAvailableAvds()
+Future<List<AvdInfo>> getAvailableAvds() async {
+  final avdHome = Platform.environment['ANDROID_AVD_HOME'] ??
+      p.join(Platform.environment['HOME']!, '.android', 'avd');
+  final avdDirectory = Directory(avdHome);
+  if (!await avdDirectory.exists()) {
+    print('❌ AVD directory does not exist at $avdHome');
+    return [];
+  }
+  final avdDirs = await avdDirectory
+      .list()
+      .where((entity) => entity is Directory && entity.path.endsWith('.avd'))
+      .toList();
+  List<AvdInfo> avds = [];
+  for (final entity in avdDirs) {
+    final dir = entity as Directory;
+    final size = await _getDirectorySize(dir);
+    final name = p.basenameWithoutExtension(dir.path);
+    avds.add(AvdInfo(name: name, sizeBytes: size));
+  }
+  return avds;
+}

package/lib/src/version.dart

@@ -0,0 +1,37 @@
+import 'dart:io';
+import 'package:yaml/yaml.dart';
+
+String getVersion() {
+  try {
+    // Look for pubspec.yaml in the project root
+    final pubspecPath = _findPubspecPath();
+
+    if (pubspecPath != null && File(pubspecPath).existsSync()) {
+      final pubspecContent = File(pubspecPath).readAsStringSync();
+      final pubspec = loadYaml(pubspecContent) as Map;
+      return pubspec['version'] ?? 'unknown';
+    }
+  } catch (e) {
+    // Silently fail and return unknown
+  }
+  return 'unknown';
+}
+
+/// Find pubspec.yaml by walking up the directory tree
+String? _findPubspecPath() {
+  var current = Directory.current;
+
+  while (true) {
+    final pubspecFile = File('${current.path}/pubspec.yaml');
+    if (pubspecFile.existsSync()) {
+      return pubspecFile.path;
+    }
+
+    final parent = current.parent;
+    if (parent.path == current.path) {
+      // Reached filesystem root
+      return null;
+    }
+    current = parent;
+  }
+}

package/npm/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rabi Iya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.