@jetstart/cli 1.2.0 → 1.5.0

package/dist/utils/emulator-deployer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Android Emulator Deployment utilities
+ */
+export declare class EmulatorDeployer {
+    private adbPath;
+    private serial;
+    constructor(adbPath: string, serial: string);
+    /**
+     * Install APK on emulator
+     */
+    installAPK(apkPath: string, packageName?: string): Promise<void>;
+    /**
+     * Launch app on emulator
+     */
+    launchApp(packageName: string, activityName?: string): Promise<void>;
+    /**
+     * Check if device is ready
+     */
+    isDeviceReady(): Promise<boolean>;
+    /**
+     * Wait for device to be ready
+     */
+    waitForDevice(timeout?: number): Promise<void>;
+    /**
+     * Find or select emulator
+     */
+    static findOrSelectEmulator(targetAVD?: string): Promise<EmulatorDeployer>;
+}
+//# sourceMappingURL=emulator-deployer.d.ts.map

package/dist/utils/emulator-deployer.js

@@ -0,0 +1,224 @@
+"use strict";
+/**
+ * Android Emulator Deployment utilities
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmulatorDeployer = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fs = __importStar(require("fs-extra"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const emulator_1 = require("./emulator");
+const spinner_1 = require("./spinner");
+const logger_1 = require("./logger");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class EmulatorDeployer {
+    adbPath;
+    serial;
+    constructor(adbPath, serial) {
+        this.adbPath = adbPath;
+        this.serial = serial;
+    }
+    /**
+     * Install APK on emulator
+     */
+    async installAPK(apkPath, packageName) {
+        const spinner = (0, spinner_1.startSpinner)('Installing APK on emulator...');
+        try {
+            // Verify APK exists
+            if (!(await fs.pathExists(apkPath))) {
+                throw new Error(`APK not found: ${apkPath}`);
+            }
+            // Use -r flag to reinstall if already exists
+            const { stdout, stderr } = await execAsync(`"${this.adbPath}" -s ${this.serial} install -r "${apkPath}"`);
+            if (stderr && stderr.includes('INSTALL_FAILED')) {
+                throw new Error(stderr);
+            }
+            (0, spinner_1.stopSpinner)(spinner, true, 'APK installed on emulator');
+        }
+        catch (error) {
+            (0, spinner_1.stopSpinner)(spinner, false, 'Failed to install APK');
+            throw error;
+        }
+    }
+    /**
+     * Launch app on emulator
+     */
+    async launchApp(packageName, activityName = 'MainActivity') {
+        const spinner = (0, spinner_1.startSpinner)('Launching app on emulator...');
+        try {
+            await execAsync(`"${this.adbPath}" -s ${this.serial} shell am start -n ${packageName}/.${activityName}`);
+            (0, spinner_1.stopSpinner)(spinner, true, 'App launched on emulator');
+        }
+        catch (error) {
+            (0, spinner_1.stopSpinner)(spinner, false, 'Failed to launch app');
+            // Don't throw - launching is optional
+            (0, logger_1.error)(`Launch failed: ${error.message}`);
+        }
+    }
+    /**
+     * Check if device is ready
+     */
+    async isDeviceReady() {
+        try {
+            const { stdout } = await execAsync(`"${this.adbPath}" -s ${this.serial} shell getprop sys.boot_completed`);
+            return stdout.trim() === '1';
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Wait for device to be ready
+     */
+    async waitForDevice(timeout = 120000) {
+        const spinner = (0, spinner_1.startSpinner)('Waiting for emulator to boot...');
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            if (await this.isDeviceReady()) {
+                (0, spinner_1.stopSpinner)(spinner, true, 'Emulator ready');
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+        }
+        (0, spinner_1.stopSpinner)(spinner, false, 'Emulator boot timeout');
+        throw new Error('Emulator failed to boot within timeout');
+    }
+    /**
+     * Find or select emulator
+     */
+    static async findOrSelectEmulator(targetAVD) {
+        const avdManager = (0, emulator_1.createAVDManager)();
+        try {
+            // First, try the AVD manager approach
+            const avds = await avdManager.listAVDs();
+            const runningAVDs = avds.filter((a) => a.running);
+            if (runningAVDs.length > 0) {
+                let selectedAVD;
+                if (targetAVD) {
+                    // User specified a specific AVD
+                    selectedAVD = runningAVDs.find((a) => a.name === targetAVD);
+                    if (!selectedAVD) {
+                        throw new Error(`Emulator "${targetAVD}" is not running`);
+                    }
+                }
+                else if (runningAVDs.length === 1) {
+                    // Only one running - use it
+                    selectedAVD = runningAVDs[0];
+                    (0, logger_1.info)(`Using emulator: ${selectedAVD.name}`);
+                }
+                else {
+                    // Multiple running - prompt user
+                    const { avdName } = await inquirer_1.default.prompt([
+                        {
+                            type: 'list',
+                            name: 'avdName',
+                            message: 'Multiple emulators running. Select one:',
+                            choices: runningAVDs.map((a) => ({
+                                name: `${a.name} (${a.target || 'Unknown'})`,
+                                value: a.name,
+                            })),
+                        },
+                    ]);
+                    selectedAVD = runningAVDs.find((a) => a.name === avdName);
+                }
+                // Get serial for this AVD
+                const serial = await avdManager.findEmulatorSerial(selectedAVD.name);
+                if (serial) {
+                    const adbPath = avdManager.getADBPath();
+                    return new EmulatorDeployer(adbPath, serial);
+                }
+            }
+        }
+        catch (err) {
+            // Fallback to simpler ADB-based detection
+            (0, logger_1.info)('Falling back to ADB device detection...');
+        }
+        // Fallback: Just use adb devices directly
+        const adbPath = avdManager.getADBPath();
+        (0, logger_1.info)(`ADB path: ${adbPath}`);
+        let stdout;
+        try {
+            const result = await execAsync(`"${adbPath}" devices`);
+            stdout = result.stdout;
+            (0, logger_1.info)(`ADB devices output:\n${stdout}`);
+        }
+        catch (err) {
+            (0, logger_1.error)(`Failed to run adb devices: ${err.message}`);
+            throw new Error('Failed to detect emulators. Make sure ADB is accessible.');
+        }
+        const lines = stdout.split('\n');
+        const devices = [];
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            (0, logger_1.info)(`Checking line: "${trimmedLine}"`);
+            const match = trimmedLine.match(/^(emulator-\d+)\s+device$/);
+            if (match) {
+                devices.push(match[1]);
+                (0, logger_1.info)(`Found emulator: ${match[1]}`);
+            }
+        }
+        if (devices.length === 0) {
+            throw new Error('No running emulators found. Start one with "jetstart android-emulator"');
+        }
+        let selectedSerial;
+        if (devices.length === 1) {
+            selectedSerial = devices[0];
+            (0, logger_1.info)(`Using emulator: ${selectedSerial}`);
+        }
+        else {
+            // Multiple running - prompt user
+            const { serial } = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'serial',
+                    message: 'Multiple emulators running. Select one:',
+                    choices: devices.map((d) => ({
+                        name: d,
+                        value: d,
+                    })),
+                },
+            ]);
+            selectedSerial = serial;
+        }
+        return new EmulatorDeployer(adbPath, selectedSerial);
+    }
+}
+exports.EmulatorDeployer = EmulatorDeployer;
+//# sourceMappingURL=emulator-deployer.js.map

package/dist/utils/emulator.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Android AVD and Emulator management utilities
+ */
+import { ChildProcess } from 'child_process';
+export interface AVDInfo {
+    name: string;
+    device: string;
+    path: string;
+    target: string;
+    basedOn?: string;
+    skin?: string;
+    sdcard?: string;
+    snapshot: boolean;
+    running?: boolean;
+}
+export interface CreateAVDOptions {
+    name: string;
+    device?: string;
+    apiLevel?: number;
+    abi?: string;
+    force?: boolean;
+}
+export interface EmulatorOptions {
+    avdName: string;
+    gpu?: 'auto' | 'host' | 'swiftshader_indirect' | 'angle_indirect' | 'guest';
+    noSnapshot?: boolean;
+    noBootAnim?: boolean;
+    wipeData?: boolean;
+}
+/**
+ * AVD Manager class
+ */
+export declare class AVDManager {
+    private sdkRoot;
+    constructor(sdkRoot?: string);
+    /**
+     * Ensure SDK root is set
+     */
+    private ensureSDKRoot;
+    /**
+     * Get path to avdmanager executable
+     */
+    private getAVDManagerPath;
+    /**
+     * Get path to emulator executable
+     */
+    private getEmulatorPath;
+    /**
+     * Get path to adb executable
+     */
+    private getADBPath;
+    /**
+     * Run avdmanager command
+     */
+    private runAVDManager;
+    /**
+     * List all AVDs
+     */
+    listAVDs(): Promise<AVDInfo[]>;
+    /**
+     * Parse avdmanager list avd output
+     */
+    private parseAVDList;
+    /**
+     * Create a new AVD
+     */
+    createAVD(options: CreateAVDOptions): Promise<void>;
+    /**
+     * Delete an AVD
+     */
+    deleteAVD(name: string): Promise<void>;
+    /**
+     * Start an emulator
+     */
+    startEmulator(options: EmulatorOptions): Promise<ChildProcess>;
+    /**
+     * Stop an emulator
+     */
+    stopEmulator(avdName: string): Promise<void>;
+    /**
+     * Check if an emulator is running
+     */
+    isEmulatorRunning(avdName: string): Promise<boolean>;
+    /**
+     * Find emulator serial number by AVD name
+     */
+    private findEmulatorSerial;
+    /**
+     * Get list of available system images for emulator
+     */
+    listSystemImages(): Promise<string[]>;
+    /**
+     * Create JetStart-optimized AVD
+     */
+    createJetStartAVD(): Promise<void>;
+}
+/**
+ * Create an AVD manager instance
+ */
+export declare function createAVDManager(sdkRoot?: string): AVDManager;
+//# sourceMappingURL=emulator.d.ts.map