avd_manager 1.0.4

package/npm/README.md

@@ -0,0 +1,97 @@
+# AVD Manager CLI
+
+Welcome to **AVD Manager CLI** — a simple and efficient command-line tool for managing Android Virtual Devices (AVDs) directly from your terminal.
+
+This quick-start guide will help you install, configure, and use the CLI in just a few steps.
+
+## 🧩 Prerequisites
+
+Before you begin, make sure you have:
+
+- **Android SDK** installed
+- **Java JDK 11+**
+- **Android SDK tools** (`avdmanager`, `sdkmanager`) available in your PATH
+- **Node.js** (if installing via npm)
+
+## Installation
+
+You can install AVD Manager CLI globally using npm:
+
+```bash
+npm install -g avd-manager-cli
+```
+
+or
+
+```bash
+npm i avd-manager-cli
+```
+
+Or clone the repository manually:
+
+```bash
+git clone https://github.com/Tdbo21/avd_manager.git
+cd avd_manager
+npm install
+```
+
+## First Run
+
+After installation, verify the CLI is working:
+
+```bash
+avdm --help
+```
+
+You should see a list of available commands and their usage.
+
+## 🧭 Common Commands
+
+| Command                                                  | Description              |
+| -------------------------------------------------------- | ------------------------ |
+| `avdm `list                                              | Lists all available AVDs |
+| `avdm `create `Pixel_API_35 `--device `pixel `--api `35` | Creates a new AVD        |
+| `avdm `delete `Pixel_API_35`                             | Deletes an existing AVD  |
+| `avdm `launch `Pixel_API_35`                             | Launches an existing AVD |
+
+## 🧪 Example Usage Workflow
+
+List existing AVDs
+
+```bash
+avdm list
+```
+
+Create a new AVD
+
+```bash
+avdm create Pixel_API_35 --device pixel --api 35
+```
+
+Delete an AVD
+
+```bash
+avdm delete Pixel_API_35
+```
+
+Launch an AVD
+
+```bash
+avdm launch Pixel_API_35
+```
+
+## 🧰 Troubleshooting
+
+If you encounter issues:
+
+- Ensure your Android SDK path is correctly set
+- Check permissions for the .android directory
+
+## 🧩 Next Steps
+
+- Visit the GitHub Repository - [![GitHub](https://img.shields.io/badge/GitHub-avd_manager-blue)](https://github.com/Tdebo21/avd_manager)
+- Contribute or open issues to improve the tool
+
+## License
+
+MIT

package/npm/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+const os = require("os");
+const path = require("path");
+const { spawn } = require("child_process");
+
+const platform = os.platform();
+let binary = "";
+
+if (platform === "darwin") binary = "avdm-macos";
+else if (platform === "win32") binary = "avdm-win.exe";
+else binary = "avdm-linux";
+
+const binPath = path.join(__dirname, "bin", binary);
+
+const child = spawn(binPath, process.argv.slice(2), { stdio: "inherit" });
+child.on("exit", (code) => process.exit(code));

package/npm/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "avd-manager-cli",
+  "version": "1.0.3",
+  "license": "MIT",
+  "description": "A command-line tool to manage Android Virtual Devices (AVDs) with ease.",
+  "bin": {
+    "avdm": "index.js"
+  },
+  "files": [
+    "index.js",
+    "bin/"
+  ],
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ]
+}

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "avd_manager",
+  "version": "1.0.4",
+  "description": "A Dart CLI tool for AVD management",
+  "scripts": {
+    "release": "standard-version",
+    "release:minor": "standard-version --release-as minor",
+    "release:major": "standard-version --release-as major",
+    "release:dry-run": "standard-version --dry-run",
+    "version": "node scripts/sync-versions.js && git add pubspec.yaml",
+    "postversion": "git push && git push --tags"
+  },
+  "devDependencies": {
+    "standard-version": "^9.5.0"
+  }
+}

package/pubspec.yaml

@@ -0,0 +1,28 @@
+name: avd_manager
+description:
+  A lightweight CLI tool to create, patch, launch, delete, list, sort, and filter Android Virtual Devices (AVDs).
+  Like Android Studio's AVD Manager, but in your terminal.
+
+version: 1.0.4 # Change from 1.0.2 to 1.0.4
+
+# author: Tdebo21
+repository: https://github.com/Tdebo21/avd_manager
+homepage: https://Tdebo21.github.io/avd_manager
+issue_tracker: https://github.com/Tdebo21/avd_manager/
+documentation: https://github.com/Tdebo21/avd_manager
+
+environment:
+  sdk: ">=3.0.0 <4.0.0"
+
+dependencies:
+  process_run: ^1.0.1
+  path: ^1.9.0
+  args: ^2.5.0
+  yaml: ^3.1.0
+
+executables:
+  avdm: avdm # Refers to bin/avdm.dart
+
+dev_dependencies:
+  lints: ^6.0.0
+  test: ^1.24.0

package/scripts/debug_list_devices.dart

@@ -0,0 +1,15 @@
+import 'package:avd_manager/avd_utils.dart';
+
+Future<void> main() async {
+  final result = await runAvdManager(['list', 'device']);
+  print('exit=${result.exitCode}');
+  print('stdout=<<${result.stdout}>>');
+  print('stderr=<<${result.stderr}>>');
+  final regex = RegExp(r'id: \d+ or "(.*?)"');
+  for (final line in result.stdout.toString().split('\n')) {
+    final match = regex.firstMatch(line);
+    if (match != null) {
+      print('MATCH: ${match.group(1)}');
+    }
+  }
+}

package/scripts/sync-versions.js

@@ -0,0 +1,13 @@
+const fs = require("fs");
+const path = require("path");
+
+// Read version from package.json
+const packageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));
+const version = packageJson.version;
+
+// Update pubspec.yaml
+let pubspec = fs.readFileSync("pubspec.yaml", "utf8");
+pubspec = pubspec.replace(/^version: .+$/m, `version: ${version}`);
+fs.writeFileSync("pubspec.yaml", pubspec);
+
+console.log(`✓ Synced version to ${version} in pubspec.yaml`);

package/test/create_command_test.dart

@@ -0,0 +1,38 @@
+// test/create_command_test.dart
+
+import 'package:test/test.dart';
+import 'package:args/args.dart';
+
+void main() {
+  test('create command has required options', () {
+    final parser = ArgParser()
+      ..addFlag('help', abbr: 'h', negatable: false, help: 'Show usage')
+      ..addCommand(
+          'create',
+          ArgParser()
+            ..addOption('device', help: 'Device name (e.g. "pixel")')
+            ..addOption('api', help: 'API level (e.g. 28)')
+            ..addOption('abi',
+                help:
+                    'ABI for the system image (e.g. x86, x86_64, arm64-v8a)'));
+
+    // Simulate running: `avd_manager create --device TestDevice --api android-33 --abi arm64-v8a`
+    final results = parser.parse([
+      'create',
+      '--device',
+      'TestDevice',
+      '--api',
+      'android-33',
+      '--abi',
+      'arm64-v8a'
+    ]);
+
+    final command = results.command;
+
+    expect(command, isNotNull);
+    expect(command!.name, equals('create'));
+    expect(command['device'], equals('TestDevice'));
+    expect(command['api'], equals('android-33'));
+    expect(command['abi'], equals('arm64-v8a'));
+  });
+}

package/test/list_avds_test.dart

@@ -0,0 +1,76 @@
+// test/list_avds_test.dart
+
+import 'package:test/test.dart';
+import 'package:args/command_runner.dart';
+import 'package:avd_manager/commands/list.dart';
+import 'dart:async';
+
+class ListCommand extends Command {
+  @override
+  final name = 'list';
+  @override
+  final description = 'Lists available AVDs.';
+
+  @override
+  void run() {
+    print('Listing all AVDs...');
+    // Simulate list output
+    print(' - pixel (API 33)');
+    print(' - nexus (API 30)');
+  }
+}
+
+void main() {
+  group('ListCommand', () {
+    test('prints list of AVDs', () async {
+      final runner = CommandRunner('avd_manager', 'Test CLI')
+        ..addCommand(ListCommand());
+
+      final printLogs = <String>[];
+      final specPrint = ZoneSpecification(
+        print: (self, parent, zone, line) {
+          printLogs.add(line);
+        },
+      );
+
+      await Zone.current.fork(specification: specPrint).run(() async {
+        await runner.run(['list']);
+      });
+
+      expect(printLogs, contains('Listing all AVDs...'));
+      expect(printLogs.any((line) => line.contains('pixel')), isTrue);
+    });
+  });
+
+  group('parseSize', () {
+    test('parses GB correctly', () {
+      expect(parseSize('2GB'), equals(2 * 1024 * 1024 * 1024));
+    });
+
+    test('parses MB correctly', () {
+      expect(parseSize('512MB'), equals(512 * 1024 * 1024));
+    });
+
+    test('throws on invalid input', () {
+      expect(() => parseSize('0'), throwsA(isA<FormatException>()));
+      expect(() => parseSize('-100MB'), throwsA(isA<FormatException>()));
+    });
+
+    test('throws on invalid unit', () {
+      expect(() => parseSize('100Z'), throwsA(isA<FormatException>()));
+    });
+
+    test('throws on empty string', () {
+      expect(() => parseSize(''), throwsA(isA<FormatException>()));
+    });
+  });
+  group('formatSize', () {
+    test('formats size in GB', () {
+      expect(formatSize(3 * 1024 * 1024 * 1024), contains('3.00 GB'));
+    });
+
+    test('formats size in MB', () {
+      expect(formatSize(700 * 1024 * 1024), contains('700.00 MB'));
+    });
+  });
+}

package/test/utils_test.dart

@@ -0,0 +1,52 @@
+import 'package:test/test.dart';
+import 'package:avd_manager/avd_utils.dart';
+
+void main() {
+  group('arg parser', () {
+    test('parses list args correctly', () {
+      final args = parseArguments(['list', '--sort', 'size']);
+      expect(args['sort'], equals('size'));
+      expect(args['min-size'], equals('0'));
+      expect(args.containsKey('command'), isFalse);
+      expect(args['name'], isNull);
+      expect(args['min-size'], isNotNull);
+      expect(args['list'], isNull);
+    });
+
+    test('returns null on empty args, and correct values on populated args',
+        () {
+      final args = parseArguments([]);
+      expect(args, isA<Map<String, String>>());
+      expect(args.length, equals(2));
+      expect(args.containsKey('sort'), isTrue);
+      expect(args.containsKey('min-size'), isTrue);
+      expect(args['sort'], equals('name'));
+      expect(args['min-size'], equals('0'));
+      expect(args['command'], isNull);
+    });
+  });
+
+// Function to format size in bytes to a human-readable string
+  // ignore: no_leading_underscores_for_local_identifiers
+  String _formatSize(int bytes) {
+    if (bytes < 1024) return '$bytes B';
+    final kb = bytes / 1024;
+    if (kb < 1024) return '${kb.toStringAsFixed(1)} KB';
+    final mb = kb / 1024;
+    if (mb < 1024) return '${mb.toStringAsFixed(1)} MB';
+    final gb = mb / 1024;
+    return '${gb.toStringAsFixed(1)} GB';
+  }
+
+  group('formatSize', () {
+    test('formats bytes correctly', () {
+      expect(_formatSize(500), equals('500 B'));
+      expect(_formatSize(1024), equals('1.0 KB'));
+      expect(_formatSize(1536), equals('1.5 KB'));
+      expect(_formatSize(1048576), equals('1.0 MB'));
+      expect(_formatSize(1572864), equals('1.5 MB'));
+      expect(_formatSize(1073741824), equals('1.0 GB'));
+      expect(_formatSize(1610612736), equals('1.5 GB'));
+    });
+  });
+}