@capawesome/cli 4.17.3 → 4.18.0-dev.9810ff51.1785743282

package/dist/commands/apps/import.test.js

@@ -0,0 +1,308 @@
+import { DEFAULT_API_BASE_URL } from '../../config/consts.js';
+import authorizationService from '../../services/authorization-service.js';
+import userConfig from '../../utils/user-config.js';
+import zip from '../../utils/zip.js';
+import consola from 'consola';
+import fs from 'fs';
+import nock from 'nock';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import importCommand from './import.js';
+// Mock dependencies
+vi.mock('@/utils/user-config.js');
+vi.mock('@/utils/prompt.js');
+vi.mock('@/services/authorization-service.js');
+vi.mock('consola');
+vi.mock('@/utils/environment.js', () => ({
+    isInteractive: () => false,
+}));
+describe('apps-import', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockAuthorizationService = vi.mocked(authorizationService);
+    const organizationId = 'org-123';
+    let fixtureDirectory;
+    let exportFile;
+    let consoleLogSpy;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockUserConfig.read.mockReturnValue({ token: 'test-token' });
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue('test-token');
+        mockAuthorizationService.hasAuthorizationToken.mockReturnValue(true);
+        vi.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process exited with code ${code}`);
+        });
+        consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        vi.spyOn(console, 'table').mockImplementation(() => undefined);
+        fixtureDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'apps-import-test-'));
+    });
+    afterEach(() => {
+        nock.cleanAll();
+        vi.restoreAllMocks();
+        fs.rmSync(fixtureDirectory, { recursive: true, force: true });
+    });
+    const writeExportFile = async (apps) => {
+        const exportDirectory = path.join(fixtureDirectory, 'export');
+        for (const app of apps) {
+            for (const [fileName, content] of Object.entries(app.files)) {
+                const filePath = path.join(exportDirectory, 'apps', app.folder, fileName);
+                fs.mkdirSync(path.dirname(filePath), { recursive: true });
+                if (typeof content === 'string' || Buffer.isBuffer(content)) {
+                    fs.writeFileSync(filePath, content);
+                }
+                else {
+                    fs.writeFileSync(filePath, JSON.stringify(content));
+                }
+            }
+        }
+        const buffer = await zip.zipFolder(exportDirectory);
+        exportFile = path.join(fixtureDirectory, 'export.zip');
+        fs.writeFileSync(exportFile, buffer);
+    };
+    const getJsonOutput = () => {
+        const jsonCall = consoleLogSpy.mock.calls.find((call) => {
+            try {
+                JSON.parse(call[0]);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        expect(jsonCall).toBeDefined();
+        return JSON.parse(jsonCall?.[0]);
+    };
+    it('should import an app with all resources', async () => {
+        await writeExportFile([
+            {
+                folder: 'My App-6668c18c',
+                files: {
+                    'app-detail.json': { id: '6668c18c', name: 'My App', appType: 'capacitor' },
+                    'repo-association.json': {
+                        gitProvider: 'github',
+                        cloneUrl: 'https://github.com/robingenz/appflow-export-test.git',
+                    },
+                    'environments.json': [{ id: 1, name: 'Production', vars: { KEY: 'value' }, secrets: { API_KEY: 'secret' } }],
+                    'live-update-channels.json': [{ id: 'channel-uuid', name: 'Production' }],
+                    'native-configs.json': [
+                        { id: 2, name: 'Production', configs: { base: { name: 'My App', bundle_id: 'dev.example.app' } } },
+                    ],
+                    'native-build-automations.json': [
+                        {
+                            name: 'Android Release',
+                            gitBranch: 'main',
+                            platform: 'android',
+                            buildType: 'release',
+                            environmentId: 1,
+                            webhook: null,
+                            automationEnabled: false,
+                            nativeConfigId: 2,
+                            signingCertificateId: 3,
+                            destinationId: null,
+                        },
+                    ],
+                    'web-build-automations.json': [],
+                    'signing-certificates/android/Debug-3/android-signing-certificate.json': {
+                        id: 3,
+                        name: 'Debug',
+                        keystoreFile: 'keystore.jks',
+                        keystorePassword: 'test1234',
+                        keyAlias: 'key',
+                        keyPassword: 'test1234',
+                    },
+                    'signing-certificates/android/Debug-3/keystore.jks': Buffer.from('keystore'),
+                },
+            },
+        ]);
+        const appId = 'app-456';
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get('/v1/apps')
+            .query({ organizationId, limit: 50, offset: 0 })
+            .reply(200, [])
+            .post('/v1/apps', { name: 'My App', type: 'capacitor' })
+            .query({ organizationId })
+            .reply(201, { id: appId, name: 'My App', type: 'capacitor' })
+            .post(`/v1/apps/${appId}/certificates`)
+            .reply(201, { id: 'certificate-1', name: 'Debug' })
+            .post(`/v1/apps/${appId}/environments`, { appId, name: 'Production' })
+            .reply(201, { id: 'environment-1', name: 'Production' })
+            .post(`/v1/apps/${appId}/environments/environment-1/variables/set`, [{ key: 'KEY', value: 'value' }])
+            .reply(200)
+            .post(`/v1/apps/${appId}/environments/environment-1/secrets/set`, [{ key: 'API_KEY', value: 'secret' }])
+            .reply(200)
+            .get(`/v1/apps/${appId}/channels`)
+            .reply(200, [])
+            .post(`/v1/apps/${appId}/channels`, { appId, name: 'Production' })
+            .reply(201, { id: 'channel-1', name: 'Production' })
+            .post(`/v1/apps/${appId}/configurations`, {
+            name: 'Production',
+            displayName: 'My App',
+            packageName: 'dev.example.app',
+        })
+            .reply(201, { id: 'configuration-1', name: 'Production' })
+            .post(`/v1/apps/${appId}/automations`, (body) => {
+            return (body.name === 'Android Release' &&
+                body.platform === 'android' &&
+                body.triggerType === 'branch' &&
+                body.triggerPattern === 'main' &&
+                body.buildType === 'release' &&
+                body.enabled === false &&
+                body.appCertificateName === 'Debug' &&
+                body.appConfigurationName === 'Production' &&
+                body.appEnvironmentName === 'Production');
+        })
+            .reply(201, { id: 'automation-1', name: 'Android Release' })
+            .put(`/v1/apps/${appId}/repository`, {
+            ownerSlug: 'robingenz',
+            provider: 'github',
+            repositorySlug: 'appflow-export-test',
+        })
+            .reply(200, { id: appId });
+        await importCommand.action({ file: exportFile, organizationId, json: true }, undefined);
+        expect(scope.isDone()).toBe(true);
+        const output = getJsonOutput();
+        expect(output.dryRun).toBe(false);
+        expect(output.apps).toHaveLength(1);
+        expect(output.apps[0]).toMatchObject({
+            id: appId,
+            name: 'My App',
+            sourceId: '6668c18c',
+            sourceName: 'My App',
+            created: { automations: 1, certificates: 1, channels: 1, configurations: 1, destinations: 0, environments: 1 },
+            errors: [],
+        });
+        expect(output.apps[0].webUrl).toContain(appId);
+    });
+    it('should rename the app if the name is already taken', async () => {
+        await writeExportFile([
+            {
+                folder: 'My App-6668c18c',
+                files: { 'app-detail.json': { id: '6668c18c', name: 'My App', appType: 'capacitor' } },
+            },
+        ]);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get('/v1/apps')
+            .query({ organizationId, limit: 50, offset: 0 })
+            .reply(200, [{ id: 'app-1', name: 'My App', type: 'capacitor' }])
+            .post('/v1/apps', { name: 'My App (2)', type: 'capacitor' })
+            .query({ organizationId })
+            .reply(201, { id: 'app-789', name: 'My App (2)', type: 'capacitor' })
+            .get('/v1/apps/app-789/channels')
+            .reply(200, []);
+        await importCommand.action({ file: exportFile, organizationId, json: true }, undefined);
+        expect(scope.isDone()).toBe(true);
+        const output = getJsonOutput();
+        expect(output.apps[0].name).toBe('My App (2)');
+        expect(output.apps[0].notes).toContainEqual(expect.stringContaining('`My App (2)`'));
+    });
+    it('should continue with the remaining resources if one fails', async () => {
+        await writeExportFile([
+            {
+                folder: 'My App-6668c18c',
+                files: {
+                    'app-detail.json': { id: '6668c18c', name: 'My App', appType: 'capacitor' },
+                    'environments.json': [{ id: 1, name: 'Production', vars: { KEY: 'value' }, secrets: null }],
+                    'live-update-channels.json': [{ id: 'channel-uuid', name: 'Production' }],
+                },
+            },
+        ]);
+        const appId = 'app-456';
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get('/v1/apps')
+            .query({ organizationId, limit: 50, offset: 0 })
+            .reply(200, [])
+            .post('/v1/apps', { name: 'My App', type: 'capacitor' })
+            .query({ organizationId })
+            .reply(201, { id: appId, name: 'My App', type: 'capacitor' })
+            .post(`/v1/apps/${appId}/environments`, { appId, name: 'Production' })
+            .reply(400, { message: 'Bad Request' })
+            .get(`/v1/apps/${appId}/channels`)
+            .reply(200, [])
+            .post(`/v1/apps/${appId}/channels`, { appId, name: 'Production' })
+            .reply(201, { id: 'channel-1', name: 'Production' });
+        await expect(importCommand.action({ file: exportFile, organizationId, json: true }, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(scope.isDone()).toBe(true);
+        const output = getJsonOutput();
+        expect(output.apps[0].created).toMatchObject({ channels: 1, environments: 0 });
+        expect(output.apps[0].errors).toContainEqual(expect.stringContaining('Production'));
+    });
+    it('should not create any resources with the dry run option', async () => {
+        await writeExportFile([
+            {
+                folder: 'My App-6668c18c',
+                files: {
+                    'app-detail.json': { id: '6668c18c', name: 'My App', appType: 'capacitor' },
+                    'environments.json': [{ id: 1, name: 'Production', vars: { KEY: 'value' }, secrets: null }],
+                },
+            },
+        ]);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get('/v1/apps')
+            .query({ organizationId, limit: 50, offset: 0 })
+            .reply(200, []);
+        await importCommand.action({ file: exportFile, organizationId, dryRun: true, json: true }, undefined);
+        expect(scope.isDone()).toBe(true);
+        const output = getJsonOutput();
+        expect(output.dryRun).toBe(true);
+        expect(output.apps[0].id).toBeNull();
+        expect(output.apps[0].webUrl).toBeNull();
+    });
+    it('should only import the apps matching the include filters', async () => {
+        await writeExportFile([
+            {
+                folder: 'App One-11111111',
+                files: { 'app-detail.json': { id: '11111111', name: 'App One', appType: 'capacitor' } },
+            },
+            {
+                folder: 'App Two-22222222',
+                files: { 'app-detail.json': { id: '22222222', name: 'App Two', appType: 'capacitor' } },
+            },
+            {
+                folder: 'App Three-33333333',
+                files: { 'app-detail.json': { id: '33333333', name: 'App Three', appType: 'capacitor' } },
+            },
+        ]);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get('/v1/apps')
+            .query({ organizationId, limit: 50, offset: 0 })
+            .reply(200, [])
+            .post('/v1/apps', { name: 'App One', type: 'capacitor' })
+            .query({ organizationId })
+            .reply(201, { id: 'app-1', name: 'App One', type: 'capacitor' })
+            .get('/v1/apps/app-1/channels')
+            .reply(200, [])
+            .post('/v1/apps', { name: 'App Three', type: 'capacitor' })
+            .query({ organizationId })
+            .reply(201, { id: 'app-3', name: 'App Three', type: 'capacitor' })
+            .get('/v1/apps/app-3/channels')
+            .reply(200, []);
+        await importCommand.action({ file: exportFile, organizationId, include: ['App One,33333333'], json: true }, undefined);
+        expect(scope.isDone()).toBe(true);
+        const output = getJsonOutput();
+        expect(output.apps).toHaveLength(2);
+        expect(output.apps.map((app) => app.sourceName)).toEqual(['App One', 'App Three']);
+    });
+    it('should report skipped apps with an unsupported app type', async () => {
+        await writeExportFile([
+            {
+                folder: 'RN App-22222222',
+                files: { 'app-detail.json': { id: '22222222', name: 'RN App', appType: 'react_native' } },
+            },
+        ]);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get('/v1/apps')
+            .query({ organizationId, limit: 50, offset: 0 })
+            .reply(200, []);
+        await importCommand.action({ file: exportFile, organizationId, json: true }, undefined);
+        expect(scope.isDone()).toBe(true);
+        const output = getJsonOutput();
+        expect(output.apps).toEqual([]);
+        expect(output.skippedApps).toEqual([
+            { sourceId: '22222222', sourceName: 'RN App', reason: expect.stringContaining('react_native') },
+        ]);
+    });
+    it('should error in non-interactive environment if no file is provided', async () => {
+        await expect(importCommand.action({ organizationId }, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(vi.mocked(consola).error).toHaveBeenCalledWith('You must provide the export file path when running in non-interactive environment.');
+    });
+});

package/dist/index.js

@@ -26,16 +26,24 @@ const config = defineConfig({
         'apps:create': await import('./commands/apps/create.js').then((mod) => mod.default),
         'apps:delete': await import('./commands/apps/delete.js').then((mod) => mod.default),
         'apps:get': await import('./commands/apps/get.js').then((mod) => mod.default),
+        // Relative path because tsc-alias fails to rewrite the alias after the key `'apps:import'`
+        'apps:import': await import('./commands/apps/import.js').then((mod) => mod.default),
         'apps:link': await import('./commands/apps/link.js').then((mod) => mod.default),
         'apps:list': await import('./commands/apps/list.js').then((mod) => mod.default),
         'apps:transfer': await import('./commands/apps/transfer.js').then((mod) => mod.default),
         'apps:unlink': await import('./commands/apps/unlink.js').then((mod) => mod.default),
+        'apps:automations:create': await import('./commands/apps/automations/create.js').then((mod) => mod.default),
+        'apps:automations:delete': await import('./commands/apps/automations/delete.js').then((mod) => mod.default),
+        'apps:automations:get': await import('./commands/apps/automations/get.js').then((mod) => mod.default),
+        'apps:automations:list': await import('./commands/apps/automations/list.js').then((mod) => mod.default),
+        'apps:automations:update': await import('./commands/apps/automations/update.js').then((mod) => mod.default),
         'apps:builds:cancel': await import('./commands/apps/builds/cancel.js').then((mod) => mod.default),
         'apps:builds:create': await import('./commands/apps/builds/create.js').then((mod) => mod.default),
         'apps:builds:failure-summary': await import('./commands/apps/builds/failure-summary.js').then((mod) => mod.default),
         'apps:builds:get': await import('./commands/apps/builds/get.js').then((mod) => mod.default),
         'apps:builds:list': await import('./commands/apps/builds/list.js').then((mod) => mod.default),
         'apps:builds:logs': await import('./commands/apps/builds/logs.js').then((mod) => mod.default),
+        'apps:builds:run': await import('./commands/apps/builds/run.js').then((mod) => mod.default),
         'apps:builds:share': await import('./commands/apps/builds/share.js').then((mod) => mod.default),
         'apps:builds:unshare': await import('./commands/apps/builds/unshare.js').then((mod) => mod.default),
         'apps:builds:download': await import('./commands/apps/builds/download.js').then((mod) => mod.default),
@@ -54,6 +62,11 @@ const config = defineConfig({
         'apps:channels:pause': await import('./commands/apps/channels/pause.js').then((mod) => mod.default),
         'apps:channels:resume': await import('./commands/apps/channels/resume.js').then((mod) => mod.default),
         'apps:channels:update': await import('./commands/apps/channels/update.js').then((mod) => mod.default),
+        'apps:configurations:create': await import('./commands/apps/configurations/create.js').then((mod) => mod.default),
+        'apps:configurations:delete': await import('./commands/apps/configurations/delete.js').then((mod) => mod.default),
+        'apps:configurations:get': await import('./commands/apps/configurations/get.js').then((mod) => mod.default),
+        'apps:configurations:list': await import('./commands/apps/configurations/list.js').then((mod) => mod.default),
+        'apps:configurations:update': await import('./commands/apps/configurations/update.js').then((mod) => mod.default),
         'apps:deployments:create': await import('./commands/apps/deployments/create.js').then((mod) => mod.default),
         'apps:deployments:cancel': await import('./commands/apps/deployments/cancel.js').then((mod) => mod.default),
         'apps:deployments:failure-summary': await import('./commands/apps/deployments/failure-summary.js').then((mod) => mod.default),

package/dist/services/app-automations.js

@@ -0,0 +1,64 @@
+import authorizationService from '../services/authorization-service.js';
+import httpClient from '../utils/http-client.js';
+class AppAutomationsServiceImpl {
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    async create(dto) {
+        const { appId, ...bodyData } = dto;
+        const response = await this.httpClient.post(`/v1/apps/${appId}/automations`, bodyData, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+    async delete(dto) {
+        await this.httpClient.delete(`/v1/apps/${dto.appId}/automations/${dto.automationId}`, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+    }
+    async findAll(dto) {
+        const params = {};
+        if (dto.limit !== undefined) {
+            params.limit = dto.limit.toString();
+        }
+        if (dto.name) {
+            params.name = dto.name;
+        }
+        if (dto.offset !== undefined) {
+            params.offset = dto.offset.toString();
+        }
+        if (dto.platform) {
+            params.platform = dto.platform;
+        }
+        const response = await this.httpClient.get(`/v1/apps/${dto.appId}/automations`, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+            params,
+        });
+        return response.data;
+    }
+    async findOneById(dto) {
+        const response = await this.httpClient.get(`/v1/apps/${dto.appId}/automations/${dto.automationId}`, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+    async update(dto) {
+        const { appId, automationId, ...bodyData } = dto;
+        await this.httpClient.patch(`/v1/apps/${appId}/automations/${automationId}`, bodyData, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+    }
+}
+const appAutomationsService = new AppAutomationsServiceImpl(httpClient);
+export default appAutomationsService;

package/dist/services/app-configurations.js

@@ -0,0 +1,77 @@
+import authorizationService from '../services/authorization-service.js';
+import httpClient from '../utils/http-client.js';
+class AppConfigurationsServiceImpl {
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    async create(dto) {
+        const { appId, ...bodyData } = dto;
+        const response = await this.httpClient.post(`/v1/apps/${appId}/configurations`, bodyData, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+    async delete(dto) {
+        if (dto.id) {
+            await this.httpClient.delete(`/v1/apps/${dto.appId}/configurations/${dto.id}`, {
+                headers: {
+                    Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+                },
+            });
+        }
+        else if (dto.name) {
+            await this.httpClient.delete(`/v1/apps/${dto.appId}/configurations`, {
+                headers: {
+                    Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+                },
+                params: {
+                    name: dto.name,
+                },
+            });
+        }
+    }
+    async findAll(dto) {
+        const params = {};
+        if (dto.limit !== undefined) {
+            params.limit = dto.limit.toString();
+        }
+        if (dto.name) {
+            params.name = dto.name;
+        }
+        if (dto.offset !== undefined) {
+            params.offset = dto.offset.toString();
+        }
+        if (dto.query) {
+            params.query = dto.query;
+        }
+        const response = await this.httpClient.get(`/v1/apps/${dto.appId}/configurations`, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+            params,
+        });
+        return response.data;
+    }
+    async findOneById(dto) {
+        const response = await this.httpClient.get(`/v1/apps/${dto.appId}/configurations/${dto.id}`, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+    async update(dto) {
+        const { appId, configurationId, ...bodyData } = dto;
+        const response = await this.httpClient.patch(`/v1/apps/${appId}/configurations/${configurationId}`, bodyData, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+}
+const appConfigurationsService = new AppConfigurationsServiceImpl(httpClient);
+export default appConfigurationsService;

package/dist/types/app-automation.js

@@ -0,0 +1 @@
+export {};

package/dist/types/app-configuration.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.js

@@ -1,4 +1,5 @@
 export * from './app-apple-api-key.js';
+export * from './app-automation.js';
 export * from './app-build-source.js';
 export * from './app-bundle.js';
 export * from './app-certificate.js';

package/dist/utils/android-emulator.js

@@ -0,0 +1,170 @@
+import { getCodeFromUnknownError, UserError } from '../utils/error.js';
+import { wait } from '../utils/wait.js';
+import { execFileSync, spawn } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+const BOOT_POLL_INTERVAL_IN_MS = 2000;
+const BOOT_TIMEOUT_IN_MS = 300000;
+/**
+ * Find all Android emulators (AVDs) installed on this machine.
+ */
+export const findAllAndroidEmulators = () => {
+    const ids = runEmulator(['-list-avds'])
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const serialById = findAllRunningAndroidEmulators();
+    return ids.map((id) => {
+        const serial = serialById.get(id) ?? null;
+        const { displayName, sdkVersion } = getAndroidEmulatorConfig(id);
+        return {
+            id,
+            name: displayName ?? id,
+            running: !!serial,
+            sdkVersion,
+            serial,
+        };
+    });
+};
+/**
+ * Boot an Android emulator and wait until it has finished booting.
+ *
+ * Returns the serial of the running emulator.
+ */
+export const bootAndroidEmulator = async (emulator) => {
+    if (emulator.serial) {
+        return emulator.serial;
+    }
+    const child = spawn(getAndroidToolPath('emulator', 'emulator'), ['-avd', emulator.id], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    const deadline = Date.now() + BOOT_TIMEOUT_IN_MS;
+    while (Date.now() < deadline) {
+        await wait(BOOT_POLL_INTERVAL_IN_MS);
+        const serial = findAllRunningAndroidEmulators().get(emulator.id);
+        if (serial && isAndroidEmulatorBooted(serial)) {
+            return serial;
+        }
+    }
+    throw new UserError(`The emulator "${emulator.name}" did not finish booting in time.`);
+};
+/**
+ * Install an APK on a running Android emulator.
+ */
+export const installAndroidApp = (serial, apkPath) => {
+    runAdb(['-s', serial, 'install', '-r', apkPath]);
+};
+/**
+ * Launch an app on a running Android emulator.
+ */
+export const launchAndroidApp = (serial, packageName) => {
+    runAdb(['-s', serial, 'shell', 'monkey', '-p', packageName, '-c', 'android.intent.category.LAUNCHER', '1']);
+};
+/**
+ * Map the AVD ID of every running emulator to its serial.
+ */
+const findAllRunningAndroidEmulators = () => {
+    const serials = runAdb(['devices'])
+        .split('\n')
+        .slice(1)
+        .map((line) => line.split('\t')[0]?.trim())
+        .filter((serial) => !!serial && serial.startsWith('emulator-'));
+    const serialById = new Map();
+    for (const serial of serials) {
+        if (!serial) {
+            continue;
+        }
+        try {
+            const id = runAdb(['-s', serial, 'emu', 'avd', 'name']).split('\n')[0]?.trim();
+            if (id) {
+                serialById.set(id, serial);
+            }
+        }
+        catch {
+            // Ignore emulators that do not respond to the console command.
+        }
+    }
+    return serialById;
+};
+/**
+ * Read the display name and API level of an emulator from its AVD configuration.
+ */
+const getAndroidEmulatorConfig = (id) => {
+    try {
+        const config = fs.readFileSync(path.join(getAndroidAvdHome(), `${id}.avd`, 'config.ini'), 'utf-8');
+        return {
+            displayName: config.match(/^avd\.ini\.displayname=(.+)$/m)?.[1]?.trim() ?? null,
+            sdkVersion: config.match(/android-(\d+)/)?.[1] ?? null,
+        };
+    }
+    catch {
+        return { displayName: null, sdkVersion: null };
+    }
+};
+const getAndroidAvdHome = () => {
+    const avdHome = process.env.ANDROID_AVD_HOME;
+    if (avdHome) {
+        return avdHome;
+    }
+    const sdkHome = process.env.ANDROID_SDK_HOME;
+    return sdkHome ? path.join(sdkHome, '.android', 'avd') : path.join(os.homedir(), '.android', 'avd');
+};
+const isAndroidEmulatorBooted = (serial) => {
+    try {
+        return runAdb(['-s', serial, 'shell', 'getprop', 'sys.boot_completed']).trim() === '1';
+    }
+    catch {
+        return false;
+    }
+};
+const runAdb = (args) => run(getAndroidToolPath('platform-tools', 'adb'), args, 'adb');
+const runEmulator = (args) => run(getAndroidToolPath('emulator', 'emulator'), args, 'emulator');
+const run = (command, args, toolName) => {
+    try {
+        return execFileSync(command, args, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] });
+    }
+    catch (error) {
+        if (getCodeFromUnknownError(error) === 'ENOENT') {
+            throw new UserError(`Could not find "${toolName}". Make sure the Android SDK is installed and either the ANDROID_HOME or ANDROID_SDK_ROOT environment variable points to it.`);
+        }
+        const stderr = error.stderr?.trim();
+        throw new UserError(stderr ? `The command "${toolName}" failed: ${stderr}` : `The command "${toolName}" failed.`);
+    }
+};
+/**
+ * Resolve an Android SDK tool, falling back to the `PATH` if the SDK cannot be located.
+ */
+const getAndroidToolPath = (directory, binary) => {
+    const sdkRoot = getAndroidSdkRoot();
+    if (sdkRoot) {
+        const toolPath = path.join(sdkRoot, directory, binary);
+        if (fs.existsSync(toolPath)) {
+            return toolPath;
+        }
+    }
+    return binary;
+};
+const getAndroidSdkRoot = () => {
+    const sdkRoot = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT;
+    if (sdkRoot) {
+        return sdkRoot;
+    }
+    const defaultSdkRoot = getDefaultAndroidSdkRoot();
+    return fs.existsSync(defaultSdkRoot) ? defaultSdkRoot : undefined;
+};
+const getDefaultAndroidSdkRoot = () => {
+    switch (process.platform) {
+        case 'darwin': {
+            return path.join(os.homedir(), 'Library', 'Android', 'sdk');
+        }
+        case 'win32': {
+            return path.join(os.homedir(), 'AppData', 'Local', 'Android', 'Sdk');
+        }
+        default: {
+            return path.join(os.homedir(), 'Android', 'Sdk');
+        }
+    }
+};